module klang.ir.编译.IR编译_;
import 全局;
import std.conv: ·to = to;
import std.functional: ·fd = toDelegate;
import ··IR节点_ = klang.ir.语法节点.IR节点_;
import klang.编译.编译.编译_: 编译器_;
import 核心 = klang.编译.核心.核心_;
import 基础节点 = klang.编译.语法节点.节点_;
import 路径模块 = klang.编译.路径.路径_;
import 系统 = klang.编译.系统.系统_;
import klang.编译.核心.核心_: 整数_, 词典_, 查找, 循环每个, 创建词典, 创建数组, 开始包含, 查找数组索引, 创建词典从关联数组, 返回零值, 是数字类的, 是十六进制字符, hexDigitValue, 查找字符索引;
import klang.编译.路径.路径_: 路径_, 正规化路径和片段, 获取目录路径;
import klang.编译.语法节点.节点_: 节点_, 令牌_, 源文件_, 令牌种类_, 节点数组_, 是失踪列表, 是失踪节点, 文本字面量_, 数字字面量_, 字面量类节点_, 创建基础节点 = 创建节点;
import klang.编译.类型.枚举值.枚举值_: SK, TK, 字符_, 令牌标志_;
import klang.编译.类型.类型_: 编译器基类_, 前端编译器接口_;
import 编译数字 = 编译数字.编译;
import klang.编译.诊断集.诊断集_: 诊断集_;
import klang.编译.诊断.诊断_: 诊断消息_, 诊断_;
import klang.ir.节点工厂.IR工厂_: 节点工厂标志_, IR工厂_;
import klang.ir.类型.IR类型_: ISK, 节点标志_, 类型_ = IR类型_, TypeID_, 整数类型位数范围_, AttrKind_, 标识符分类_;
import klang.ir.常量值.IR常量值_: 获取ISK关键字文本, 获取组合标点令牌, 标识符转ISK, 转换SK为ISK;
import klang.ir.语法节点.IR节点_: 创建节点, IR节点_, IR标识符_, 语句_, 修饰符_, IR源文件_, IR令牌_, 标识符_, 字面量类表达式基类_, IR数字字面量_, IR文本字面量_, 类型节点_, 结构类型_, 数组类型_, 自定义特性设置_, 对齐设置_, 向量类型_, 地址空间设置_, 不透明指针类型_, 指针类型_, 对齐堆栈设置_, 分配大小设置_, 分配大小设置内容_, 倍数范围设置_, 倍数范围设置内容_, 形参声明_, 函数类型_, 全局表达式_, 表达式_, 结构常量表达式_, 向量常量表达式_, 数组常量表达式_, c文本常量_, 内联汇编常量表达式_, 块地址表常量表达式_, DSO局部等效常量表达式_, 常量转换类节点_, 提取值常量表达式_, 插入值常量表达式_, 比较类常量表达式_, 取反常量表达式_, 二元常量表达式_, 逻辑类常量表达式_, 获取元素指针常量表达式_, 向量洗牌常量表达式_, 插入元素常量表达式_, 提取元素常量表达式_, 选择常量表达式_, 封装设置_, 值表达式_, 跳转表元素_, MDNode_, MDNodeVector_, DIExpression_, DIArgList_, 专用元数据字段_, 元数据字段_, 数据计算字段_, 返回指令_, 跳转指令_, 假如指令_, 直接跳转指令_, 唤出指令_, 操作数标签_, 操作数标签组_, 实参表达式_, 重启指令_, 清理返回指令_, 捕获返回指令_, 捕获分支指令_, 捕获场指令_, 清理场指令_, 调用跳转指令_, 取反指令_, 整数和差积及左移指令_, 小数和差积及左移指令_, 有无符号求商及右移指令_, 有无符号求余数运算指令_, 位运算指令_, 比较运算指令_, 转换类指令_, 可变参数指令_, 提取元素指令_, 插入元素指令_, 洗牌向量指令_, PHI节点元素_, PHI节点指令_, 选择指令_, 捕获或过滤器_, 着陆场指令_, 冻结指令_, 调用指令_, 分配指令_, 同步范围设置_, 加载指令_, 储存指令_, 原子修改内存按条件指令_, 原子修改内存指令_, 栅格指令_, 获取元素指针指令_, 提取值指令_, 插入值指令_, 用户历史数据_, 局部变量声明_, 块声明_, 按引用设置_, 按值设置_, 结构引用设置_, 预分配设置_, 在内部分配设置_, 类型声明_, 封装声明_, 特性声明_, 元数据声明_, 用户历史数据_基本块_, 本地线程设置_, 函数体_, 函数声明_, 函数定义_, 别名声明_, 全局变量声明_, 模块级汇编_, 独立元数据_, 不及指令_, IRc文本字面量_, 摘要节点_, 全局摘要声明_, 全局值摘要_, 摘要多值设置_, 摘要值设置_, 全局值引用摘要_, 被调用者摘要_, 虚函数id摘要_, 常量虚调用摘要_, 虚函数摘要_, 别名摘要_, 形参偏移摘要_, 形参访问调用摘要_, 形参访问摘要_, 函数摘要_, 变量摘要_, 模块摘要_, 偏移及引用_, 类型id内容摘要_, 类型id兼容表摘要_, 是局部声明语句;
alias 数字文本_ = dstring;
alias 正整数文本_ = dstring;
alias 小数文本_ = dstring;
alias 类型文本_ = dstring;
alias 文本内容_ = dstring;
编译器_ 编译器 = ··null!(编译器_);
ISK 当前令牌 = ISK.未知__;
ISK 当前ISK = ISK.未知__;
ISK 结尾令牌 = ISK.未知__;
IR源文件_ 源文件;
long 编译上下文 = 0;
类型_[] 声明的未命名类型数组;
核心.词典_!(类型_) 声明的已命名类型组;
核心.词典_!(类型_) 声明的整数类型;
bool 跳过摘要 = true;
bool 冒号是标识符 = false;
klang.ir.编译.IR编译_._MD专用编译_ _MDP;
long 小数标志 = 0;
long 整数标志 = 0;
long 文本标志 = 0;
long 文本8标志 = 0;
dstring APFloatVal;
dstring StrValRaw;
dstring StrVal;
dstring CStrValRaw;
string CStrVal;
dstring UIntVal;
dstring APSIntVal;
dstring TyVal;
IR数字字面量_ _APFloatVal;
IR文本字面量_ _StrVal;
IRc文本字面量_ _CStrVal;
IR数字字面量_ _UIntVal;
IR数字字面量_ _APSIntVal;
IR数字字面量_ _TyVal;
bool 解码为c文本常量 = false;
IR工厂_ 工厂;
long 下个节点的开始 = 0;
static this() {
    声明的未命名类型数组 = 创建数组!(类型_)();
    声明的已命名类型组 = 创建词典!(类型_)();
    声明的整数类型 = 创建词典!(类型_)();
    _MDP = new klang.ir.编译.IR编译_._MD专用编译_();
    工厂 = new IR工厂_(节点工厂标志_.无_, 节点标志_.无);
}
class 前端编译器_ : 前端编译器接口_ {
    编译器_ 编译器;
    this() { }
    this(编译器基类_ 编译) {
        this.编译器 = (cast(编译器_)(编译));
        .编译器 = this.编译器;
    }
    基础节点.源文件_ 编译源文件() {
        assert((this.编译器.当前源文件 !is ··null!(基础节点.源文件_)) && this.编译器.当前源文件.目标 == TK.Ir, "不是前端'ir'支持的目标"c);
        .源文件 = (cast(IR源文件_)(this.编译器.当前源文件));
        .下个();
        源文件.语句组 = ·to!(基础节点.节点数组_!(基础节点.节点_))(.编译源文件平台());
        源文件.文件结尾令牌 = 编译器.编译文件结尾令牌();
        源文件.开始 = 0;
        源文件.结束 = 源文件.文件结尾令牌.结束;
        源文件.标识符数量 = 编译器.标识符数量;
        return .源文件;
    }
    void 清理() {
        编译器.清理();
        .当前令牌 = ISK.未知__;
        .当前ISK = ISK.未知__;
        .结尾令牌 = ISK.未知__;
        .源文件 = ··null!(IR源文件_);
        .编译上下文 = 0;
    }
}
private class _MD专用编译_ {
    private 核心.词典_!(bool) _MD_去重词典;
    IR节点_[] 数据组;
    this() {
        this._MD_去重词典 = new 核心.词典_!(bool)();
        this.数据组 = 创建数组!(IR节点_)();
    }
    private void _MD_去重复位() {
        this._MD_去重词典.清除();
    }
    private bool _MD_已经存在(dstring 名称) {
        if (this._MD_去重词典.具有(名称)) {
            return true;
        }
        this._MD_去重词典.p·设置(名称, true);
        return false;
    }
    IR节点_ parseMDFieldsImpl(void delegate() fn, IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)) fn2) {
        IR文本字面量_ Val = .getStrVal();
        IR标识符_ ID = 工厂.创建IR标识符(标识符分类_.元数据标识符_, Val);
        long 开始 = Val.开始;
        .编译确定的(ISK.左括号);
        this._MD_去重复位();
        long 数组开始 = .获取节点开始();
        bool 第一层 = false;
        while(!第一层 || .编译可选的(ISK.逗号)) {
            第一层 = true;
            assert(.当前() == ISK.LabelStr, "不是LabelStr"c);
            fn();
        }
        基础节点.节点数组_!(IR节点_) 节点数组 = .创建节点数组!(IR节点_)(this.数据组, 数组开始);
        this.数据组 = 创建数组!(IR节点_)();
        .编译确定的(ISK.右括号);
        return fn2(ID, 节点数组);
    }
    IR节点_ 完成专用节点(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    IR节点_ 完成DILocation(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("scope"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DILocation"d, "scope"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DILocation() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "column"d) {
            .追加!(IR节点_)(this.数据组, this.编译ColumnField(str));
        }
        else if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str, false));
        }
        else if (内容 == "inlinedAt"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "isImplicitCode"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DILocation"d]);
        }
    }
    IR节点_ 完成GenericDINode(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("tag"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!GenericDINode"d, "tag"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译GenericDINode() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "tag"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfTagField(str));
        }
        else if (内容 == "header"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "operands"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDFieldList(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!GenericDINode"d]);
        }
    }
    void 编译DISubrange() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "count"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedOrMDField(str, false));
        }
        else if (内容 == "lowerBound"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedOrMDField(str));
        }
        else if (内容 == "upperBound"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedOrMDField(str));
        }
        else if (内容 == "stride"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedOrMDField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DISubrange"d]);
        }
    }
    void 编译DIGenericSubrange() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "count"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedOrMDField(str));
        }
        else if (内容 == "lowerBound"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedOrMDField(str));
        }
        else if (内容 == "upperBound"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedOrMDField(str));
        }
        else if (内容 == "stride"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedOrMDField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIGenericSubrange"d]);
        }
    }
    IR节点_ 完成DIEnumerator(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("name"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIEnumerator"d, "name"d]);
        }
        if (!this._MD_已经存在("value"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIEnumerator"d, "value"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DIEnumerator() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "value"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDAPSIntField(str));
        }
        else if (内容 == "isUnsigned"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIEnumerator"d]);
        }
    }
    void 编译DIBasicType() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "tag"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfTagField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "size"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "align"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "encoding"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfAttEncodingField(str));
        }
        else if (内容 == "flags"d) {
            .追加!(IR节点_)(this.数据组, this.编译DIFlagField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIBasicType"d]);
        }
    }
    void 编译DIStringType() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "tag"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfTagField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "stringLength"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "stringLengthExpression"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "size"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "align"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "encoding"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfAttEncodingField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIStringType"d]);
        }
    }
    IR节点_ 完成DIDerivedType(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("tag"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIDerivedType"d, "tag"d]);
        }
        if (!this._MD_已经存在("baseType"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIDerivedType"d, "baseType"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DIDerivedType() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "tag"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfTagField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "baseType"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "size"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "align"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "offset"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "flags"d) {
            .追加!(IR节点_)(this.数据组, this.编译DIFlagField(str));
        }
        else if (内容 == "extraData"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "dwarfAddressSpace"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIDerivedType"d]);
        }
    }
    IR节点_ 完成DICompositeType(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("tag"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DICompositeType"d, "tag"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DICompositeType() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "tag"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfTagField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "baseType"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "size"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "align"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "offset"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "flags"d) {
            .追加!(IR节点_)(this.数据组, this.编译DIFlagField(str));
        }
        else if (内容 == "elements"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "runtimeLang"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfLangField(str));
        }
        else if (内容 == "vtableHolder"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "templateParams"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "identifier"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "discriminator"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "dataLocation"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "associated"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "allocated"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "rank"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedOrMDField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DICompositeType"d]);
        }
    }
    IR节点_ 完成DISubroutineType(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("types"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DISubroutineType"d, "types"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DISubroutineType() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "flags"d) {
            .追加!(IR节点_)(this.数据组, this.编译DIFlagField(str));
        }
        else if (内容 == "cc"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfCCField(str));
        }
        else if (内容 == "types"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DISubroutineType"d]);
        }
    }
    IR节点_ 完成DIFileType(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("filename"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIFileType"d, "filename"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DIFileType() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "filename"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "directory"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "checksumkind"d) {
            .追加!(IR节点_)(this.数据组, this.编译ChecksumKindField(str));
        }
        else if (内容 == "checksum"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "source"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIFileType"d]);
        }
    }
    IR节点_ 完成DICompileUnit(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("language"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DICompileUnit"d, "language"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DICompileUnit() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "language"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfLangField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "producer"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "isOptimized"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "flags"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "runtimeVersion"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "splitDebugFilename"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "emissionKind"d) {
            .追加!(IR节点_)(this.数据组, this.编译EmissionKindField(str));
        }
        else if (内容 == "enums"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "retainedTypes"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "globals"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "imports"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "macros"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "dwoId"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "splitDebugInlining"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "debugInfoForProfiling"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "nameTableKind"d) {
            .追加!(IR节点_)(this.数据组, this.编译NameTableKindField(str));
        }
        else if (内容 == "rangesBaseAddress"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "sysroot"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "sdk"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DICompileUnit"d]);
        }
    }
    void 编译DISubprogram() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "linkageName"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "type"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "isLocal"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "isDefinition"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "scopeLine"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "containingType"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "virtuality"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfVirtualityField(str));
        }
        else if (内容 == "virtualIndex"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "thisAdjustment"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDSignedField(str));
        }
        else if (内容 == "flags"d) {
            .追加!(IR节点_)(this.数据组, this.编译DIFlagField(str));
        }
        else if (内容 == "spFlags"d) {
            .追加!(IR节点_)(this.数据组, this.编译DISPFlagField(str));
        }
        else if (内容 == "isOptimized"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "unit"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "templateParams"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "declaration"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "retainedNodes"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "thrownTypes"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DISubprogram"d]);
        }
    }
    IR节点_ 完成DILexicalBlock(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("scope"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DILexicalBlock"d, "scope"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DILexicalBlock() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "column"d) {
            .追加!(IR节点_)(this.数据组, this.编译ColumnField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DILexicalBlock"d]);
        }
    }
    IR节点_ 完成DILexicalBlockFile(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("scope"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DILexicalBlockFile"d, "scope"d]);
        }
        if (!this._MD_已经存在("discriminator"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DILexicalBlockFile"d, "discriminator"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DILexicalBlockFile() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "discriminator"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DILexicalBlockFile"d]);
        }
    }
    IR节点_ 完成DICommonBlock(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("scope"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DICommonBlock"d, "scope"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DICommonBlock() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "declaration"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DICommonBlock"d]);
        }
    }
    IR节点_ 完成DINamespace(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("scope"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DINamespace"d, "scope"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DINamespace() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "exportSymbols"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DINamespace"d]);
        }
    }
    IR节点_ 完成DIMacro(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("type"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIMacro"d, "type"d]);
        }
        if (!this._MD_已经存在("name"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIMacro"d, "name"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DIMacro() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "type"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfMacinfoTypeField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "value"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIMacro"d]);
        }
    }
    IR节点_ 完成DIMacroFile(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("file"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIMacroFile"d, "file"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DIMacroFile() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "type"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfMacinfoTypeField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "nodes"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIMacroFile"d]);
        }
    }
    IR节点_ 完成DIModule(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("scope"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIModule"d, "scope"d]);
        }
        if (!this._MD_已经存在("name"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIModule"d, "name"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DIModule() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "configMacros"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "includePath"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "apinotes"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "isDecl"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIModule"d]);
        }
    }
    IR节点_ 完成DITemplateTypeParameter(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("type"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DITemplateTypeParameter"d, "type"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DITemplateTypeParameter() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "type"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "defaulted"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DITemplateTypeParameter"d]);
        }
    }
    IR节点_ 完成DITemplateValueParameter(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("value"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DITemplateValueParameter"d, "value"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DITemplateValueParameter() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "tag"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfTagField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "type"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "defaulted"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "value"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DITemplateValueParameter"d]);
        }
    }
    IR节点_ 完成DIGlobalVariable(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("name"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIGlobalVariable"d, "name"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DIGlobalVariable() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "linkageName"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "type"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "isLocal"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "isDefinition"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDBoolField(str));
        }
        else if (内容 == "templateParams"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "declaration"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "align"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIGlobalVariable"d]);
        }
    }
    IR节点_ 完成DILocalVariable(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("scope"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DILocalVariable"d, "scope"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DILocalVariable() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "arg"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "type"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "flags"d) {
            .追加!(IR节点_)(this.数据组, this.编译DIFlagField(str));
        }
        else if (内容 == "align"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DILocalVariable"d]);
        }
    }
    IR节点_ 完成DILabel(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("scope"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DILabel"d, "scope"d]);
        }
        if (!this._MD_已经存在("name"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DILabel"d, "name"d]);
        }
        if (!this._MD_已经存在("file"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DILabel"d, "file"d]);
        }
        if (!this._MD_已经存在("line"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DILabel"d, "line"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DILabel() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DILabel"d]);
        }
    }
    IR节点_ 完成DIGlobalVariableExpression(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("var"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIGlobalVariableExpression"d, "var"d]);
        }
        if (!this._MD_已经存在("expr"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIGlobalVariableExpression"d, "expr"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DIGlobalVariableExpression() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "var"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "expr"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIGlobalVariableExpression"d]);
        }
    }
    void 编译DIObjCProperty() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "setter"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "getter"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else if (内容 == "attributes"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDUnsignedField(str));
        }
        else if (内容 == "type"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIGlobalVariableExpression"d]);
        }
    }
    IR节点_ 完成DIImportedEntity(IR标识符_ Val, 基础节点.节点数组_!(IR节点_) 数据组) {
        专用元数据字段_ n = 工厂.创建专用元数据字段(Val, 数据组);
        if (!this._MD_已经存在("tag"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIImportedEntity"d, "tag"d]);
        }
        if (!this._MD_已经存在("scope"d)) {
            .编译错误(Val.开始, Val.结束, 诊断集_.元数据_0_缺少必须的成员_1, ["!DIImportedEntity"d, "scope"d]);
        }
        return .完成节点!(专用元数据字段_)(n, Val.开始);
    }
    void 编译DIImportedEntity() {
        IR文本字面量_ _strValRaw = .getStrVal();
        IR标识符_ str = 工厂.创建IR标识符(标识符分类_.标识符_, _strValRaw);
        dstring 内容 = str.内容;
        if (this._MD_已经存在(内容)) {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_重复出现, [内容]);
        }
        if (内容 == "tag"d) {
            .追加!(IR节点_)(this.数据组, this.编译DwarfTagField(str));
        }
        else if (内容 == "scope"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "entity"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "file"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDField(str));
        }
        else if (内容 == "line"d) {
            .追加!(IR节点_)(this.数据组, this.编译LineField(str));
        }
        else if (内容 == "name"d) {
            .追加!(IR节点_)(this.数据组, this.编译MDStringField(str));
        }
        else {
            .编译错误(str.开始, str.结束, 诊断集_.字段_0_不是元数据_1_的有效成员, [内容, "!DIImportedEntity"d]);
        }
    }
    IR节点_ 编译MDAPSIntField(IR标识符_ 名称) {
        long 开始 = 名称.开始;
        IR数字字面量_ Val = .getAPSIntVal();
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译MDUnsignedField(IR标识符_ 名称) {
        long 开始 = 名称.开始;
        IR数字字面量_ Val = .getAPSIntVal();
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译LineField(IR标识符_ 名称) {
        return this.编译MDUnsignedField(名称);
    }
    IR节点_ 编译ColumnField(IR标识符_ 名称) {
        return this.编译MDUnsignedField(名称);
    }
    IR节点_ 编译DwarfTagField(IR标识符_ 名称) {
        if (.当前() == ISK.APSInt) {
            return this.编译MDUnsignedField(名称);
        }
        long 开始 = 名称.开始;
        IR文本字面量_ val = .getStrVal();
        IR标识符_ Val = 工厂.创建IR标识符(标识符分类_.标识符_, val);
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译DwarfMacinfoTypeField(IR标识符_ 名称) {
        if (.当前() == ISK.APSInt) {
            return this.编译MDUnsignedField(名称);
        }
        long 开始 = 名称.开始;
        IR文本字面量_ val = .getStrVal();
        IR标识符_ Val = 工厂.创建IR标识符(标识符分类_.标识符_, val);
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译DwarfVirtualityField(IR标识符_ 名称) {
        if (.当前() == ISK.APSInt) {
            return this.编译MDUnsignedField(名称);
        }
        long 开始 = 名称.开始;
        IR文本字面量_ val = .getStrVal();
        IR标识符_ Val = 工厂.创建IR标识符(标识符分类_.标识符_, val);
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译DwarfLangField(IR标识符_ 名称) {
        if (.当前() == ISK.APSInt) {
            return this.编译MDUnsignedField(名称);
        }
        long 开始 = 名称.开始;
        IR文本字面量_ val = .getStrVal();
        IR标识符_ Val = 工厂.创建IR标识符(标识符分类_.标识符_, val);
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译DwarfCCField(IR标识符_ 名称) {
        if (.当前() == ISK.APSInt) {
            return this.编译MDUnsignedField(名称);
        }
        long 开始 = 名称.开始;
        IR文本字面量_ val = .getStrVal();
        IR标识符_ Val = 工厂.创建IR标识符(标识符分类_.标识符_, val);
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译EmissionKindField(IR标识符_ 名称) {
        if (.当前() == ISK.APSInt) {
            return this.编译MDUnsignedField(名称);
        }
        long 开始 = 名称.开始;
        IR文本字面量_ val = .getStrVal();
        IR标识符_ Val = 工厂.创建IR标识符(标识符分类_.标识符_, val);
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译NameTableKindField(IR标识符_ 名称) {
        if (.当前() == ISK.APSInt) {
            return this.编译MDUnsignedField(名称);
        }
        long 开始 = 名称.开始;
        IR文本字面量_ val = .getStrVal();
        IR标识符_ Val = 工厂.创建IR标识符(标识符分类_.标识符_, val);
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译DwarfAttEncodingField(IR标识符_ 名称) {
        if (.当前() == ISK.APSInt) {
            return this.编译MDUnsignedField(名称);
        }
        long 开始 = 名称.开始;
        IR文本字面量_ val = .getStrVal();
        IR标识符_ Val = 工厂.创建IR标识符(标识符分类_.标识符_, val);
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译DIFlagField(IR标识符_ 名称) {
        元数据字段_ delegate() parseFlag;
        long 开始;
        bool 第一层;
        IR节点_[] 运算组;
        long 数组开始;
        基础节点.节点数组_!(IR节点_) 运算节点数组;
        数据计算字段_ n2;
        元数据字段_ parseFlag·func() {
            IR文本字面量_ Val1;
            元数据字段_ n1;
            if (.当前() == ISK.APSInt) {
                IR数字字面量_ Val = .getAPSIntVal();
                元数据字段_ n = 工厂.创建元数据字段(名称, Val);
                return .完成节点!(元数据字段_)(n, 开始);
            }
            Val1 = .getStrVal();
            n1 = 工厂.创建元数据字段(名称, Val1);
            return .完成节点!(元数据字段_)(n1, 开始);
        }
        parseFlag = &parseFlag·func;
        开始 = 名称.开始;
        第一层 = false;
        运算组 = 创建数组!(IR节点_)();
        数组开始 = .获取节点开始();
        while(!第一层 || .编译可选的(ISK.或号)) {
            第一层 = true;
            元数据字段_ Val2 = parseFlag();
            .追加!(IR节点_)(运算组, Val2);
        }
        运算节点数组 = .创建节点数组!(IR节点_)(运算组, 数组开始);
        n2 = 工厂.创建数据计算字段(名称, 运算节点数组);
        return .完成节点!(数据计算字段_)(n2, 开始);
    }
    IR节点_ 编译DISPFlagField(IR节点_ 名称) {
        元数据字段_ delegate() parseFlag;
        long 开始;
        bool 第一层;
        IR节点_[] 运算组;
        long 数组开始;
        基础节点.节点数组_!(IR节点_) 运算节点数组;
        数据计算字段_ n3;
        元数据字段_ parseFlag·func() {
            IR文本字面量_ Val2;
            元数据字段_ n2;
            if (.当前() == ISK.APSInt) {
                IR数字字面量_ Val1 = .getAPSIntVal();
                元数据字段_ n1 = 工厂.创建元数据字段(名称, Val1);
                return .完成节点!(元数据字段_)(n1, 开始);
            }
            Val2 = .getStrVal();
            n2 = 工厂.创建元数据字段(名称, Val2);
            return .完成节点!(元数据字段_)(n2, 开始);
        }
        parseFlag = &parseFlag·func;
        开始 = 名称.开始;
        第一层 = false;
        运算组 = 创建数组!(IR节点_)();
        数组开始 = .获取节点开始();
        while(!第一层 || .编译可选的(ISK.或号)) {
            第一层 = true;
            元数据字段_ Val3 = parseFlag();
            .追加!(IR节点_)(运算组, Val3);
        }
        运算节点数组 = .创建节点数组!(IR节点_)(运算组, 数组开始);
        n3 = 工厂.创建数据计算字段(名称, 运算节点数组);
        return .完成节点!(数据计算字段_)(n3, 开始);
    }
    IR节点_ 编译MDSignedField(IR节点_ 名称) {
        long 开始 = 名称.开始;
        IR数字字面量_ Val = .getAPSIntVal();
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    IR节点_ 编译MDStringField(IR节点_ 名称) {
        long 开始 = 名称.开始;
        IR文本字面量_ Val = .parseStringConstant();
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    元数据字段_ 编译MDBoolField(IR节点_ 名称) {
        long 开始 = 名称.开始;
        if (.当前() == ISK.true_) {
            IR节点_ tVal = .编译IR令牌节点(.当前());
            元数据字段_ n = 工厂.创建元数据字段(名称, tVal);
            return .完成节点!(元数据字段_)(n, 开始);
        }
        assert(.当前() == ISK.false_, "不是false_"c);
        IR节点_ fVal = .编译IR令牌节点(.当前());
        元数据字段_ n2 = 工厂.创建元数据字段(名称, fVal);
        return .完成节点!(元数据字段_)(n2, 开始);
    }
    元数据字段_ 编译MDField(IR节点_ 名称, bool 允许空 = true) {
        long 开始 = 名称.开始;
        if (.当前() == ISK.null_) {
            if (允许空) {
                IR节点_ nullVal = .编译IR令牌节点(.当前());
                元数据字段_ n = 工厂.创建元数据字段(名称, nullVal);
                return .完成节点!(元数据字段_)(n, 开始);
            }
            else {
            }
        }
        IR节点_ Val = .parseMetadata();
        元数据字段_ n2 = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n2, 开始);
    }
    IR节点_ 编译MDSignedOrMDField(IR节点_ 名称, bool 允许空 = true) {
        if (.当前() == ISK.APSInt) {
            return this.编译MDSignedField(名称);
        }
        return this.编译MDField(名称, 允许空);
    }
    元数据字段_ 编译MDFieldList(IR节点_ 名称, bool 允许空 = true) {
        long 开始 = 名称.开始;
        MDNodeVector_ Val = .parseMDNodeVector();
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
    元数据字段_ 编译ChecksumKindField(IR节点_ 名称, bool 允许空 = true) {
        long 开始 = 名称.开始;
        IR文本字面量_ val = .getStrVal();
        IR标识符_ Val = 工厂.创建IR标识符(标识符分类_.标识符_, val);
        元数据字段_ n = 工厂.创建元数据字段(名称, Val);
        return .完成节点!(元数据字段_)(n, 开始);
    }
}
struct IsAliasOrIfunc_ {
    IR节点_ IsAliasOrIfunc;
    IR节点_ Ty;
    IR节点_ Aliasee;
    基础节点.节点数组_!(IR节点_) IndirectSymbolAttrs;
    this(IR节点_ IsAliasOrIfunc, IR节点_ Ty, IR节点_ Aliasee, 基础节点.节点数组_!(IR节点_) IndirectSymbolAttrs) {
        this.IsAliasOrIfunc = IsAliasOrIfunc;
        this.Ty = Ty;
        this.Aliasee = Aliasee;
        this.IndirectSymbolAttrs = IndirectSymbolAttrs;
    }
}
struct 全局值_ {
    IR节点_ Ty;
    IR节点_ GOrC;
    IR节点_ AddrSpace = ··null!(IR节点_);
    IR节点_ IsExternallyInitialized = ··null!(IR节点_);
    IR节点_ G = ··null!(IR节点_);
    IR节点_ Section = ··null!(IR节点_);
    IR节点_ Alignment = ··null!(IR节点_);
    IR节点_ Partition = ··null!(IR节点_);
    基础节点.节点数组_!(IR节点_) MDS = ··null!(基础节点.节点数组_!(IR节点_));
    IR节点_ CD = ··null!(IR节点_);
    基础节点.节点数组_!(IR节点_) 函数特性 = ··null!(基础节点.节点数组_!(IR节点_));
    this(IR节点_ Ty, IR节点_ GOrC, IR节点_ AddrSpace = ··null!(IR节点_), IR节点_ IsExternallyInitialized = ··null!(IR节点_), IR节点_ G = ··null!(IR节点_), IR节点_ Section = ··null!(IR节点_), IR节点_ Alignment = ··null!(IR节点_), IR节点_ Partition = ··null!(IR节点_), 基础节点.节点数组_!(IR节点_) MDS = ··null!(基础节点.节点数组_!(IR节点_)), IR节点_ CD = ··null!(IR节点_), 基础节点.节点数组_!(IR节点_) 函数特性 = ··null!(基础节点.节点数组_!(IR节点_))) {
        this.Ty = Ty;
        this.GOrC = GOrC;
        this.AddrSpace = AddrSpace;
        this.IsExternallyInitialized = IsExternallyInitialized;
        this.G = G;
        this.Section = Section;
        this.Alignment = Alignment;
        this.Partition = Partition;
        this.MDS = MDS;
        this.CD = CD;
        this.函数特性 = 函数特性;
    }
}
struct 函数头_ {
    基础节点.节点数组_!(IR节点_) 参数列表;
    IR节点_ 返回类型;
    IR标识符_ name = ··null!(IR标识符_);
    IR节点_ 连接特性 = ··null!(IR节点_);
    IR节点_ 运行时抢占 = ··null!(IR节点_);
    IR节点_ 可见性 = ··null!(IR节点_);
    IR节点_ DLL储存类 = ··null!(IR节点_);
    IR节点_ 调用约定 = ··null!(IR节点_);
    基础节点.节点数组_!(IR节点_) 返回类型特性 = ··null!(基础节点.节点数组_!(IR节点_));
    IR节点_ 未命名的地址 = ··null!(IR节点_);
    IR节点_ 地址空间 = ··null!(IR节点_);
    基础节点.节点数组_!(IR节点_) 函数特性 = ··null!(基础节点.节点数组_!(IR节点_));
    IR节点_ 段设置 = ··null!(IR节点_);
    IR节点_ 隔板设置 = ··null!(IR节点_);
    IR节点_ 函数封装 = ··null!(IR节点_);
    IR节点_ 对齐设置 = ··null!(IR节点_);
    IR节点_ GC设置 = ··null!(IR节点_);
    全局表达式_ 前缀设置 = ··null!(全局表达式_);
    全局表达式_ 序言设置 = ··null!(全局表达式_);
    全局表达式_ 个性设置 = ··null!(全局表达式_);
    bool IsVarArg = ··null!(bool);
    this(基础节点.节点数组_!(IR节点_) 参数列表, IR节点_ 返回类型, IR标识符_ name = ··null!(IR标识符_), IR节点_ 连接特性 = ··null!(IR节点_), IR节点_ 运行时抢占 = ··null!(IR节点_), IR节点_ 可见性 = ··null!(IR节点_), IR节点_ DLL储存类 = ··null!(IR节点_), IR节点_ 调用约定 = ··null!(IR节点_), 基础节点.节点数组_!(IR节点_) 返回类型特性 = ··null!(基础节点.节点数组_!(IR节点_)), IR节点_ 未命名的地址 = ··null!(IR节点_), IR节点_ 地址空间 = ··null!(IR节点_), 基础节点.节点数组_!(IR节点_) 函数特性 = ··null!(基础节点.节点数组_!(IR节点_)), IR节点_ 段设置 = ··null!(IR节点_), IR节点_ 隔板设置 = ··null!(IR节点_), IR节点_ 函数封装 = ··null!(IR节点_), IR节点_ 对齐设置 = ··null!(IR节点_), IR节点_ GC设置 = ··null!(IR节点_), 全局表达式_ 前缀设置 = ··null!(全局表达式_), 全局表达式_ 序言设置 = ··null!(全局表达式_), 全局表达式_ 个性设置 = ··null!(全局表达式_), bool IsVarArg = ··null!(bool)) {
        this.参数列表 = 参数列表;
        this.返回类型 = 返回类型;
        this.name = name;
        this.连接特性 = 连接特性;
        this.运行时抢占 = 运行时抢占;
        this.可见性 = 可见性;
        this.DLL储存类 = DLL储存类;
        this.调用约定 = 调用约定;
        this.返回类型特性 = 返回类型特性;
        this.未命名的地址 = 未命名的地址;
        this.地址空间 = 地址空间;
        this.函数特性 = 函数特性;
        this.段设置 = 段设置;
        this.隔板设置 = 隔板设置;
        this.函数封装 = 函数封装;
        this.对齐设置 = 对齐设置;
        this.GC设置 = GC设置;
        this.前缀设置 = 前缀设置;
        this.序言设置 = 序言设置;
        this.个性设置 = 个性设置;
        this.IsVarArg = false;
    }
}
struct LinkKage_ {
    IR节点_ LinkageAux = ··null!(IR节点_);
    IR节点_ DSOLocal = ··null!(IR节点_);
    IR节点_ Visibility = ··null!(IR节点_);
    IR节点_ DLLStorageClass = ··null!(IR节点_);
}
IR数字字面量_ parseUInt32() {
    if (.APSIntVal is ··null!(dstring)) {
        return ._APSIntVal;
    }
    long k = .获取节点开始();
    IR数字字面量_ n = 工厂.创建IR数字字面量(.APSIntVal);
    n.标志 |= .整数标志;
    .整数标志 = 0;
    .APSIntVal = 返回零值!(dstring)();
    ._APSIntVal = .完成节点且前进!(IR数字字面量_)(n, k);
    _APSIntVal.整数值 = .编译正整数数字(_APSIntVal.内容, n);
    return ._APSIntVal;
}
IR数字字面量_ parseUInt64() {
    if (.APSIntVal is ··null!(dstring)) {
        return ._APSIntVal;
    }
    long k = .获取节点开始();
    IR数字字面量_ n = 工厂.创建IR数字字面量(.APSIntVal);
    n.标志 |= .整数标志;
    .整数标志 = 0;
    .APSIntVal = 返回零值!(dstring)();
    ._APSIntVal = .完成节点且前进!(IR数字字面量_)(n, k);
    _APSIntVal.整数值 = .编译正整数数字(_APSIntVal.内容, n);
    return ._APSIntVal;
}
IR文本字面量_ parseStringConstant() {
    if (.StrVal is ··null!(dstring)) {
        return ._StrVal;
    }
    long k = .获取节点开始();
    IR文本字面量_ n = 工厂.创建IR文本字面量(.StrVal);
    if ((.文本标志 & 节点标志_.未解码转义) != 0) {
        n.原始文本 = .StrValRaw;
    }
    n.标志 |= .文本标志;
    .文本标志 = 0;
    .StrValRaw = 返回零值!(dstring)();
    .StrVal = 返回零值!(dstring)();
    ._StrVal = .完成节点且前进!(IR文本字面量_)(n, k);
    return ._StrVal;
}
IR数字字面量_ getTyVal() {
    if (.TyVal is ··null!(dstring)) {
        return ._TyVal;
    }
    long k = .获取节点开始();
    IR数字字面量_ n = 工厂.创建IR数字字面量(.TyVal);
    n.标志 |= .整数标志;
    .整数标志 = 0;
    .TyVal = 返回零值!(dstring)();
    ._TyVal = .完成节点且前进!(IR数字字面量_)(n, k);
    _TyVal.整数值 = .编译正整数数字(n.内容, n);
    return ._TyVal;
}
IRc文本字面量_ getCstrVal() {
    if (.CStrVal is ··null!(string)) {
        return ._CStrVal;
    }
    long k = .获取节点开始();
    IRc文本字面量_ n = 工厂.创建IRc文本字面量(.CStrVal);
    n.原始内容 = .CStrValRaw;
    n.标志 |= .文本8标志;
    .文本标志 = 0;
    .文本8标志 = 0;
    .CStrValRaw = 返回零值!(dstring)();
    .CStrVal = 返回零值!(string)();
    .StrVal = 返回零值!(dstring)();
    ._CStrVal = .完成节点且前进!(IRc文本字面量_)(n, k);
    return ._CStrVal;
}
IR文本字面量_ getStrVal() {
    if (.StrVal is ··null!(dstring)) {
        return ._StrVal;
    }
    long k = .获取节点开始();
    IR文本字面量_ n = 工厂.创建IR文本字面量(.StrVal);
    n.标志 |= .文本标志;
    .文本标志 = 0;
    .文本8标志 = 0;
    .CStrValRaw = 返回零值!(dstring)();
    .CStrVal = 返回零值!(string)();
    .StrVal = 返回零值!(dstring)();
    ._StrVal = .完成节点且前进!(IR文本字面量_)(n, k);
    return ._StrVal;
}
ulong 编译正整数数字(dstring 数字文本, IR节点_ n) {
    try {
        return 编译数字.编译!(ulong)(数字文本, 10);
    }
    catch(Throwable _) {
        .编译错误(n.开始, n.结束, 诊断集_.不是正整数字面量表达式, [""d]);
        return 0;
    }
}
IR数字字面量_ getUIntVal() {
    if (.UIntVal is ··null!(dstring)) {
        return ._UIntVal;
    }
    long k = .获取节点开始();
    IR数字字面量_ n = 工厂.创建IR数字字面量(.UIntVal);
    n.标志 |= .整数标志;
    .整数标志 = 0;
    .UIntVal = 返回零值!(dstring)();
    ._UIntVal = .完成节点且前进!(IR数字字面量_)(n, k);
    _UIntVal.整数值 = .编译正整数数字(_UIntVal.内容, n);
    return ._UIntVal;
}
IR数字字面量_ getAPSIntVal() {
    if (.APSIntVal is ··null!(dstring)) {
        return ._APSIntVal;
    }
    long k = .获取节点开始();
    IR数字字面量_ n = 工厂.创建IR数字字面量(.APSIntVal);
    n.标志 |= .整数标志;
    .整数标志 = 0;
    .APSIntVal = 返回零值!(dstring)();
    ._APSIntVal = .完成节点且前进!(IR数字字面量_)(n, k);
    return ._APSIntVal;
}
IR数字字面量_ getAPFloatVal() {
    if (.APFloatVal is ··null!(dstring)) {
        return ._APFloatVal;
    }
    long k = .获取节点开始();
    IR数字字面量_ n = 工厂.创建IR数字字面量(.APFloatVal);
    n.标志 |= .小数标志;
    .小数标志 = 0;
    .APFloatVal = 返回零值!(dstring)();
    ._APFloatVal = .完成节点且前进!(IR数字字面量_)(n, k);
    return ._APFloatVal;
}
IR文本字面量_ parseMDString() {
    if (.StrVal is ··null!(dstring)) {
        return ._StrVal;
    }
    long k = .获取节点开始();
    IR文本字面量_ n = 工厂.创建IR文本字面量(.StrVal);
    .文本标志 |= (cast(整数_)(节点标志_.是文本内容_ | 节点标志_.MD_));
    n.标志 |= .文本标志;
    .文本标志 = 0;
    .StrVal = 返回零值!(dstring)();
    ._StrVal = .完成节点且前进!(IR文本字面量_)(n, k);
    return ._StrVal;
}
void 报告当前令牌编译错误(诊断消息_ 消息, dstring 消息实参 = " "d) {
    return 编译器.报告当前令牌编译错误(消息, 消息实参);
}
void 报告当前位置编译错误(long 起点, long 长, 诊断消息_ 消息, dstring[] 消息实参) {
    消息实参 = 消息实参.dup;
    return 编译器.报告当前位置编译错误(起点, 长, 消息, 消息实参);
}
void 编译错误在(long 起点, long 结尾, 诊断消息_ 消息, dstring 消息实参 = " "d) {
    return 编译器.编译错误在(起点, 结尾, 消息, 消息实参);
}
void 编译错误(long 起点, long 结尾, 诊断消息_ 消息, dstring[] 消息实参) {
    消息实参 = 消息实参.dup;
    return 编译器.编译错误(起点, 结尾, 消息, 消息实参);
}
诊断_[] 获取收集的诊断消息() {
    return 编译器.获取收集的诊断消息();
}
ISK 令牌() {
    return .当前令牌;
}
ISK 下个令牌() {
    .当前令牌 = .预扫描ISK(编译器.下个令牌());
    return .当前令牌;
}
ISK 当前() {
    return .当前ISK;
}
long 获取文本开始() {
    return 编译器.获取文本开始();
}
令牌标志_ 获取令牌标志() {
    return 编译器.获取令牌标志();
}
dstring 获取令牌值() {
    return 编译器.获取令牌值();
}
long 获取令牌开始() {
    return 编译器.获取令牌开始();
}
long 获取节点开始() {
    return .下个节点的开始;
}
ISK 下个(基础节点.节点_ 节点 = ··null!(基础节点.节点_), long 开始 = ··null!(long)) {
    .下个令牌();
    .下个节点的开始 = 编译器.获取节点开始();
    if (节点 !is ··null!(基础节点.节点_)) {
        编译器.f·完成节点!(基础节点.节点_)(节点, 开始, .下个节点的开始);
    }
    .当前ISK = .Lex();
    return .当前ISK;
}
T 完成节点且前进(T)(T 节点, long 开始) {
    .下个(节点, 开始);
    return 节点;
}
T 完成节点(T)(T 节点, long 开始) {
    编译器.f·完成节点!(T)(节点, 开始, .下个节点的开始);
    return 节点;
}
T 编译令牌节点(T)() {
    return 编译器.f·编译令牌节点!(T)();
}
基础节点.令牌_!(TK) 编译可选令牌节点(TK)(TK t) {
    return 编译器.f·编译可选令牌节点!(TK)(t);
}
bool 编译确定的(ISK isk, 诊断消息_ 诊断消息 = ··null!(诊断消息_), bool 应该前进 = true) {
    if (.当前() == isk) {
        if (应该前进) {
            .下个();
        }
        return true;
    }
    if (诊断消息 !is ··null!(诊断消息_)) {
        .报告当前令牌编译错误(诊断消息);
    }
    else {
        dstring 参数 = 获取ISK关键字文本(isk);
        if (参数 is ··null!(dstring)) {
            参数 = "未知令牌"d;
        }
        .报告当前令牌编译错误(诊断集_.a0_expected, 参数);
    }
    return false;
}
IR令牌_!(T) 编译确定IR令牌(T)(T tsk, 诊断消息_ 诊断消息 = ··null!(诊断消息_)) {
    IR令牌_!(T) n = .编译可选IR令牌!(T)(tsk);
    if (n !is ··null!(IR令牌_!(T))) {
        return n;
    }
    if (诊断消息 is ··null!(诊断消息_)) {
        诊断消息 = 诊断集_.a0_expected;
    }
    return .创建失踪IR节点!(IR令牌_!(T))(tsk, true, 诊断消息);
}
IR节点_ 编译IR令牌节点(ISK tsk) {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) n = new IR令牌_!(ISK)(tsk);
    return .完成节点且前进!(IR令牌_!(ISK))(n, 开始);
}
IR令牌_!(T) 编译IR令牌(T)(T tsk) {
    long 开始 = .获取节点开始();
    IR令牌_!(T) n = new IR令牌_!(T)(tsk);
    return .完成节点且前进!(IR令牌_!(T))(n, 开始);
}
IR令牌_!(T) 编译可选IR令牌(T)(T tsk) {
    if (.当前() == tsk) {
        return .编译IR令牌!(T)(tsk);
    }
    return ··null!(IR令牌_!(T));
}
bool 编译可选的(ISK isk) {
    if (.当前() == isk) {
        .下个();
        return true;
    }
    return false;
}
T 推断助手(T)(T delegate() 回调, bool 是向前看) {
    ISK 储存当前令牌 = .当前令牌;
    T 结果 = 编译器.f·推断助手!(T)(cast(T delegate())(回调), 是向前看);
    if ((结果 is ··null!(T)) || 是向前看) {
        .当前令牌 = 储存当前令牌;
    }
    return 结果;
}
T 向前看(T)(T delegate() 回调) {
    return .推断助手!(T)(cast(T delegate())(回调), true);
}
T 尝试编译(T)(T delegate() 回调) {
    return .推断助手!(T)(cast(T delegate())(回调), false);
}
bool 有间隔() {
    return (.获取令牌标志() & 令牌标志_.令牌前有杂项) != 0;
}
ISK 预扫描ISK(SK sk) {
    if (sk == SK.连续运算符) {
        return .获取令牌值() == "..."d ? ISK.三点号 : ISK.Error;
    }
    return 转换SK为ISK(sk);
}
T 创建失踪节点(T)(SK sk, bool 报告当前位置错误, 诊断消息_ 诊断消息, dstring 消息实参 = ""d) {
    return 编译器.f·创建失踪节点!(T)(sk, 报告当前位置错误, 诊断消息, 消息实参);
}
T 创建失踪IR节点(T)(ISK tsk, bool 报告当前位置错误, 诊断消息_ 诊断消息, dstring 消息实参 = ""d) {
    long 节点开始 = .获取节点开始();
    IR节点_ n = 创建节点!(IR节点_)(tsk);
    if (消息实参 == ""d) {
        消息实参 = 获取ISK关键字文本(tsk);
    }
    if (报告当前位置错误) {
        .报告当前位置编译错误(.获取节点开始(), 0, 诊断消息, [消息实参]);
    }
    else if (诊断消息 !is ··null!(诊断消息_)) {
        .报告当前令牌编译错误(诊断消息, 消息实参);
    }
    return (cast(T)(.完成节点且前进!(IR节点_)(n, 节点开始)));
}
基础节点.节点数组_!(T) 创建失踪列表(T)() {
    return 编译器.f·创建失踪列表!(T)();
}
基础节点.节点数组_!(T) 创建节点数组(T)(T[] 元素组, long 开始, long 结束 = -2) {
    return 编译器.f·创建节点数组!(T)(元素组, 开始, 结束);
}
bool 计算编译错误(基础节点.节点_ 计算的节点) {
    return 编译器.计算编译错误(计算的节点);
}
void 收集子节点数据(基础节点.节点_ 计算的节点) {
    return 编译器.收集子节点数据(计算的节点);
}
void 设置节点标志(基础节点.节点_ n, 节点标志_ 标志) {
    n.标志 |= (cast(整数_)(标志));
}
bool 前面有换行符() {
    return 编译器.前面有换行符();
}
void 设置标志(节点标志_ 标志) {
    编译器.设置当前标志(true, (cast(整数_)(标志)));
}
void 取消标志(节点标志_ 标志) {
    编译器.设置当前标志(false, (cast(整数_)(标志)));
}
bool 是标签名允许文本(dstring 内容) {
    {
        for (uint i = 0; i < 内容.length; ++i) {
            immutable(dchar) ch = 内容[i];
            if (!(ch >= 字符_.a && ch <= 字符_.z || ch >= 字符_.A && ch <= 字符_.Z || ch >= 字符_.数_0 && ch <= 字符_.数_9 || ch == 字符_.点号 || ch == 字符_.下划线 || ch == 字符_.美元 || ch == 字符_.减号)) {
                return false;
            }
        }
    }
    return 内容 != ""d;
}
bool 是元数据名允许文本(dstring 内容) {
    {
        for (uint i = 0; i < 内容.length; ++i) {
            immutable(dchar) ch = 内容[i];
            if (!(ch >= 字符_.a && ch <= 字符_.z || ch >= 字符_.A && ch <= 字符_.Z || ch >= 字符_.数_0 && ch <= 字符_.数_9 || ch == 字符_.点号 || ch == 字符_.下划线 || ch == 字符_.反斜杠 || ch == 字符_.美元 || ch == 字符_.减号)) {
                return false;
            }
        }
    }
    return 内容 != ""d;
}
bool 文本是十进制的(dstring 内容) {
    {
        for (uint i = 0; i < 内容.length; ++i) {
            if (!是数字类的(内容[i])) {
                return false;
            }
        }
    }
    return 内容 != ""d;
}
bool 文本是十六进制的(dstring 内容) {
    {
        for (int i = 0; i < 内容.length; ++i) {
            immutable(dchar) ch = 内容[i];
            if (!(ch >= 字符_.数_0 && ch <= 字符_.数_9 || ch >= 字符_.a && ch <= 字符_.f || ch >= 字符_.A && ch <= 字符_.F)) {
                return false;
            }
        }
    }
    return true;
}
dstring 尝试编译标签(bool 标识符后是冒号停止 = false) {
    dstring delegate() 内部编译;
    dstring 内部编译·func() {
        long 开始;
        dstring 内容;
        开始 = .获取节点开始();
        内容 = ""d;
        if (.令牌() == ISK.文本字面量) {
            内容 ~= .获取令牌值();
            if (.下个令牌() == ISK.冒号) {
                .文本标志 |= (cast(整数_)(节点标志_.是文本内容_));
                return 内容;
            }
            return 返回零值!(dstring)();
        }
        if (.令牌() == ISK.标识符) {
            内容 ~= .获取令牌值();
            .下个令牌();
            if (.令牌() == ISK.冒号) {
                if (标识符后是冒号停止) {
                    return 返回零值!(dstring)();
                }
                return 内容;
            }
            if (.有间隔()) {
                return 返回零值!(dstring)();
            }
            dstring 新增内容 = .获取令牌值();
            if (!.是标签名允许文本(新增内容)) {
                return 返回零值!(dstring)();
            }
        }
        while(.令牌() == ISK.美元 || .令牌() == ISK.减号 || .令牌() == ISK.点号 || .令牌() == ISK.标识符 || .令牌() == ISK.数字字面量) {
            dstring 新增内容 = .获取令牌值();
            if (!.是标签名允许文本(新增内容)) {
                return 返回零值!(dstring)();
            }
            内容 ~= 新增内容;
            .下个令牌();
            if (.有间隔()) {
                return 返回零值!(dstring)();
            }
            if (.令牌() == ISK.冒号) {
                return 内容;
            }
        }
        return 返回零值!(dstring)();
    }
    内部编译 = &内部编译·func;
    return .尝试编译!(dstring)(cast(dstring delegate())(内部编译));
}
dstring 尝试元数据名称() {
    dstring delegate() 内部编译;
    dstring 内部编译·func() {
        long 开始;
        dstring 内容;
        开始 = .获取节点开始();
        .下个令牌();
        内容 = ""d;
        while(.令牌() == ISK.美元 || .令牌() == ISK.减号 || .令牌() == ISK.点号 || .令牌() == ISK.反斜杠 || .令牌() == ISK.标识符 || .令牌() == ISK.数字字面量) {
            dstring 新增内容 = .令牌() == ISK.美元 ? "$"d : .令牌() == ISK.减号 ? "-"d : .令牌() == ISK.点号 ? "."d : .令牌() == ISK.反斜杠 ? "\\"d : .获取令牌值();
            if (!.是元数据名允许文本(新增内容)) {
                return 返回零值!(dstring)();
            }
            内容 ~= 新增内容;
            if (.应该停止(() { return (.有间隔() || (.令牌() != ISK.美元 && .令牌() != ISK.减号 && .令牌() != ISK.点号 && .令牌() != ISK.反斜杠 && .令牌() != ISK.标识符 && .令牌() != ISK.数字字面量)); })) {
                if (内容.length > 0 && 是数字类的(内容[0])) {
                    return 返回零值!(dstring)();
                }
                return 内容;
            }
            .下个令牌();
        }
        return 返回零值!(dstring)();
    }
    内部编译 = &内部编译·func;
    return .尝试编译!(dstring)(cast(dstring delegate())(内部编译));
}
ISK Lex() {
    ISK kind = .令牌();
    switch (kind) {
        case ISK.加号: {
            return .LexPositive();
        }
        case ISK.艾特: {
            return .LexAt();
        }
        case ISK.美元: {
            return .LexDollar();
        }
        case ISK.百分号: {
            return .LexPercent();
        }
        case ISK.文本字面量: {
            return .LexQuote();
        }
        case ISK.三点号: {
            return ISK.三点号;
        }
        case ISK.点号: {
            return .LexDon();
        }
        case ISK.叹号: {
            return .LexExclaim();
        }
        case ISK.异或号: {
            return .LexCaret();
        }
        case ISK.冒号: {
            return ISK.冒号;
        }
        case ISK.井号: {
            return .LexHash();
        }
        case ISK.减号:
        case ISK.数字字面量: {
            return .LexDigitOrNegative();
        }
        case ISK.文件结尾:
        case ISK.等号:
        case ISK.左方括号:
        case ISK.右方括号:
        case ISK.左大括号:
        case ISK.右大括号:
        case ISK.左尖括号:
        case ISK.右尖括号:
        case ISK.左括号:
        case ISK.右括号:
        case ISK.逗号:
        case ISK.星号:
        case ISK.或号: {
            return .令牌();
        }
        default: {
            return .LexIdentifier();
        }
    }
}
ISK LexPositive() {
    long 开始 = .获取节点开始();
    dstring 前面 = .获取令牌值();
    .下个令牌();
    assert(.令牌() == ISK.数字字面量 && (.获取令牌标志() & 令牌标志_.是小数_) != 0, "不是小数"c);
    dstring 内容 = .获取令牌值();
    dstring 小数内容 = 前面 ~ 内容;
    .小数标志 = (cast(整数_)(节点标志_.IEEEdouble));
    .APFloatVal = 小数内容;
    return ISK.APFloat;
}
ISK LexAt() {
    return .LexVar(ISK.GlobalVar, ISK.GlobalID);
}
ISK LexVar(ISK Var, ISK VarID) {
    long 开始 = .获取节点开始();
    .下个令牌();
    if (.令牌() == ISK.文本字面量) {
        .StrVal = .获取令牌值();
        .文本标志 |= (cast(整数_)(节点标志_.是文本内容_));
        return Var;
    }
    dstring 标识符 = .ReadVarName();
    if (标识符 !is ··null!(dstring)) {
        .StrVal = 标识符;
        return Var;
    }
    return .LexUIntID(VarID, 开始);
}
ISK LexUIntID(ISK VarID, long 开始) {
    assert(.令牌() == ISK.数字字面量 && .文本是十进制的(.获取令牌值()), "不文本是十进制的"c);
    .整数标志 |= (cast(整数_)(节点标志_.正整数64_));
    .UIntVal = .获取令牌值();
    return VarID;
}
bool 应该停止(bool delegate() fn) {
    return .向前看!(bool)(() {
        .下个令牌();
        return fn();
    });
}
dstring ReadVarName() {
    dstring delegate() 内部编译;
    dstring 内部编译·func() {
        long 开始;
        dstring 内容;
        开始 = .获取节点开始();
        内容 = ""d;
        while(.令牌() == ISK.标识符 || .令牌() == ISK.点号 || .令牌() == ISK.减号 || .令牌() == ISK.美元 || .令牌() == ISK.数字字面量) {
            内容 ~= (.令牌() == ISK.标识符 || .令牌() == ISK.数字字面量) ? .获取令牌值() : .令牌() == ISK.减号 ? "-"d : .令牌() == ISK.点号 ? "."d : "$"d;
            if (.应该停止(() { return (.有间隔() || (.令牌() != ISK.标识符 && .令牌() != ISK.数字字面量 && .令牌() != ISK.点号 && .令牌() != ISK.减号 && .令牌() != ISK.美元)); })) {
                if (内容.length > 0 && 是数字类的(内容[0])) {
                    return 返回零值!(dstring)();
                }
                return 内容;
            }
            .下个令牌();
        }
        return 返回零值!(dstring)();
    }
    内部编译 = &内部编译·func;
    return .尝试编译!(dstring)(cast(dstring delegate())(内部编译));
}
ISK LexDollar() {
    long 开始 = .获取节点开始();
    .下个令牌();
    dstring 标签 = .尝试编译标签();
    if (标签 !is ··null!(dstring)) {
        .StrVal = 标签;
        return ISK.LabelStr;
    }
    if (.令牌() == ISK.文本字面量) {
        .StrVal = .获取令牌值();
        .文本标志 |= (cast(整数_)(节点标志_.是文本内容_));
        return ISK.ComdatVar;
    }
    dstring 标识符 = .ReadVarName();
    if (标识符 !is ··null!(dstring)) {
        .StrVal = 标识符;
        return ISK.ComdatVar;
    }
    return ISK.未知__;
}
ISK LexPercent() {
    return .LexVar(ISK.LocalVar, ISK.LocalVarID);
}
ISK LexQuote() {
    ISK kind = .ReadString(ISK.StringConstant);
    if (!.有间隔() && .令牌() == ISK.冒号) {
        .下个令牌();
        return ISK.LabelStr;
    }
    return kind;
}
ISK ReadString(ISK isk) {
    令牌标志_ 令牌标志 = .获取令牌标志() & 令牌标志_.未解码转义;
    dstring 令牌内容 = .获取令牌值();
    .文本标志 |= (cast(整数_)(节点标志_.是文本内容_));
    if (令牌标志 != 令牌标志_.None) {
        bool 有错误 = false;
        if (.解码为c文本常量) {
            .文本8标志 = (cast(整数_)(节点标志_.未解码转义));
            .CStrValRaw = 令牌内容;
            .CStrVal = .解码转义字符!(char)(·to!(string)(令牌内容), 有错误);
        }
        else {
            .文本标志 |= (cast(整数_)(节点标志_.未解码转义));
            string 文本8内容 = .解码转义字符!(char)(·to!(string)(令牌内容), 有错误);
            .StrValRaw = 令牌内容;
            .StrVal = ·to!(dstring)(文本8内容);
        }
        if (有错误) {
            .下个();
            return ISK.Error;
        }
    }
    else if (.解码为c文本常量) {
        .CStrValRaw = 令牌内容;
        .CStrVal = ·to!(string)(令牌内容);
        .StrVal = 返回零值!(dstring)();
    }
    else {
        .CStrVal = 返回零值!(string)();
        .StrVal = 令牌内容;
    }
    return isk;
}
immutable(T)[] 解码转义字符(T)(immutable(T)[] 内容, ref bool 存在错误编码) {
    void delegate(immutable(T)[]) 分解处理;
    immutable(T)[] 原始内容;
    T[] 结果;
    void 分解处理·func(immutable(T)[] str) {
        {
            for (long i = 0; i < str.length; ++i) {
                T ch;
                ch = (cast()(str[i]));
                if (ch == 字符_.反斜杠) {
                    long 开始 = i;
                    T[] chars = 创建数组!(T)();
                    bool 第一层 = false;
                    while(!第一层 || ch == 字符_.反斜杠) {
                        第一层 = true;
                        T a = (cast()(str[i + 1]));
                        T b = (cast()(str[i + 2]));
                        if (!是十六进制字符(a) || !是十六进制字符(b)) {
                            存在错误编码 = true;
                            return;
                        }
                        T 编码结果 = (cast(T)(hexDigitValue(a) * 16 + hexDigitValue(b)));
                        .追加!(T)(chars, 编码结果);
                        i += 3;
                        if (i >= str.length) {
                            break;
                        }
                        ch = (cast()(str[i]));
                    }
                    long 结束 = i;
                    .追加!(T)(结果, (cast(T[])(str[0 .. 开始])));
                    .追加!(T)(结果, chars);
                    return 分解处理(str[结束 .. $]);
                }
            }
        }
        .追加!(T)(结果, (cast(T[])(str)));
    }
    分解处理 = &分解处理·func;
    原始内容 = 内容;
    结果 = 创建数组!(T)();
    分解处理(内容);
    return 存在错误编码 ? 原始内容 : (cast(immutable(T)[])(结果));
}
ISK LexDon() {
    dstring 标签 = .尝试编译标签();
    if (标签 !is ··null!(dstring)) {
        .StrVal = 标签;
        return ISK.LabelStr;
    }
    return ISK.点号;
}
ISK LexExclaim() {
    dstring 元数据名 = .尝试元数据名称();
    if (元数据名 !is ··null!(dstring)) {
        long index = 查找字符索引(元数据名, 字符_.反斜杠);
        if (index >= 0) {
            bool 有错误 = false;
            元数据名 = .解码转义字符!(dchar)(元数据名, 有错误);
            if (有错误) {
                .下个();
                .StrVal = 返回零值!(dstring)();
                return ISK.Error;
            }
        }
        .StrVal = 元数据名;
        return ISK.MetadataVar;
    }
    return ISK.叹号;
}
ISK LexCaret() {
    long 开始 = .获取节点开始();
    .下个令牌();
    return .LexUIntID(ISK.SummaryID, 开始);
}
ISK LexHash() {
    long 开始 = .获取节点开始();
    .下个令牌();
    return .LexUIntID(ISK.AttrGrpID, 开始);
}
ISK LexDigitOrNegative() {
    long 开始 = .获取节点开始();
    bool 是负号 = .令牌() == ISK.减号;
    dstring 标签 = .尝试编译标签();
    if (标签 !is ··null!(dstring)) {
        if (!是负号) {
            try {
                编译数字.编译!(ulong)(标签, 10);
                .UIntVal = 标签;
                return ISK.LabelID;
            }
            catch(Throwable _) {
            }
        }
        .StrVal = 标签;
        return ISK.LabelStr;
    }
    dstring 内容 = ""d;
    if (是负号) {
        .下个令牌();
        内容 ~= "-"d;
    }
    if (.令牌() == ISK.数字字面量 && (.获取令牌标志() & 令牌标志_.是小数_) == 0) {
        // APInt_
        内容 ~= .获取令牌值();
        if (内容 == "0"d && .向前看!(bool)(cast(bool delegate())(·fd(&.是0x)))) {
            return .Lex0x();
        }
        if (是负号) {
            .整数标志 |= (cast(整数_)(节点标志_.是有符号的_));
        }
        .整数标志 |= (cast(整数_)(节点标志_.数字或负数_));
        .APSIntVal = 内容;
        return ISK.APSInt;
    }
    if (是负号) {
        .小数标志 |= (cast(整数_)(节点标志_.是有符号的_));
    }
    .小数标志 |= (cast(整数_)(节点标志_.IEEEdouble));
    .APFloatVal = 内容 ~ .获取令牌值();
    return ISK.APFloat;
}
bool 是0x() {
    .下个令牌();
    if (.令牌() != ISK.标识符) {
        return false;
    }
    dstring 值 = .获取令牌值();
    return 值[0] == 字符_.x || 值[0] == 字符_.X;
}
ISK Lex0x() {
    long 开始 = .获取节点开始();
    .下个令牌();
    assert(.令牌() == ISK.标识符, "内容不是 0x..."c);
    dstring 内容 = .获取令牌值();
    if (内容 == ""d || 内容.length <= 1) {
        return ISK.Error;
    }
    immutable(dchar) ch0 = 内容[0];
    if (ch0 != 字符_.x || ch0 != 字符_.X) {
        return ISK.Error;
    }
    dchar ch1 = 字符_.空字符;
    dchar ch = (cast()(内容[1]));
    if (ch == 字符_.K || ch == 字符_.L || ch == 字符_.M || ch == 字符_.H || ch == 字符_.R) {
        ch1 = ch;
        if (内容.length <= 2) {
            return ISK.Error;
        }
        内容 = 内容[2 .. $];
    }
    if (ch1 == 字符_.空字符) {
        ch1 = 字符_.J;
        内容 = 内容[1 .. $];
    }
    .APFloatVal = 内容;
    if (ch1 == 字符_.J) {
        .小数标志 |= (cast(整数_)(节点标志_.IEEEdouble));
    }
    if (ch1 == 字符_.K) {
        .小数标志 |= (cast(整数_)(节点标志_.x87DoubleExtended));
    }
    if (ch1 == 字符_.L) {
        .小数标志 |= (cast(整数_)(节点标志_.IEEEquad));
    }
    if (ch1 == 字符_.M) {
        .小数标志 |= (cast(整数_)(节点标志_.PPCDoubleDouble));
    }
    if (ch1 == 字符_.H) {
        .小数标志 |= (cast(整数_)(节点标志_.IEEEhalf));
    }
    else {
        .小数标志 |= (cast(整数_)(节点标志_.BFloat));
    }
    return ISK.APFloat;
}
ISK LexIdentifier() {
    long 开始 = .获取节点开始();
    if (.令牌() != ISK.标识符) {
        return ISK.Error;
    }
    dstring 标签 = .尝试编译标签(.冒号是标识符);
    if (标签 !is ··null!(dstring)) {
        .StrVal = 标签;
        return ISK.LabelStr;
    }
    dstring 内容 = .获取令牌值();
    immutable(dchar) ch0 = 内容[0];
    if (ch0 == 字符_.i) {
        dstring 应该是整数 = 内容[1 .. $];
        if (.文本是十进制的(应该是整数)) {
            uint 整数位数 = 编译数字.编译!(uint)(应该是整数, 10);
            if (整数类型位数范围_.MIN_INT_BITS > 整数位数 || 整数位数 > 整数类型位数范围_.MAX_INT_BITS) {
                return ISK.Error;
            }
            .TyVal = 应该是整数;
            return ISK.Type;
        }
    }
    ISK kind = 标识符转ISK(内容, ISK.标识符);
    if (kind != ISK.标识符) {
        return kind;
    }
    if (开始包含(内容, "DW_TAG_"d)) {
        .StrVal = 内容;
        return ISK.DwarfTag;
    }
    if (开始包含(内容, "DW_ATE_"d)) {
        .StrVal = 内容;
        return ISK.DwarfAttEncoding;
    }
    if (开始包含(内容, "DW_VIRTUALITY_"d)) {
        .StrVal = 内容;
        return ISK.DwarfVirtuality;
    }
    if (开始包含(内容, "DW_LANG_"d)) {
        .StrVal = 内容;
        return ISK.DwarfLang;
    }
    if (开始包含(内容, "DW_CC_"d)) {
        .StrVal = 内容;
        return ISK.DwarfCC;
    }
    if (开始包含(内容, "DW_OP_"d)) {
        .StrVal = 内容;
        return ISK.DwarfOp;
    }
    if (开始包含(内容, "DW_MACINFO_"d)) {
        .StrVal = 内容;
        return ISK.DwarfMacinfo;
    }
    if (开始包含(内容, "DIFlag"d)) {
        .StrVal = 内容;
        return ISK.DIFlag;
    }
    if (开始包含(内容, "DISPFlag"d)) {
        .StrVal = 内容;
        return ISK.DISPFlag;
    }
    if (开始包含(内容, "CSK_"d)) {
        .StrVal = 内容;
        return ISK.ChecksumKind;
    }
    if (内容 == "NoDebug"d || 内容 == "FullDebug"d || 内容 == "LineTablesOnly"d || 内容 == "DebugDirectivesOnly"d) {
        .StrVal = 内容;
        return ISK.EmissionKind;
    }
    if (内容 == "GNU"d || 内容 == "None"d || 内容 == "Default"d) {
        .StrVal = 内容;
        return ISK.NameTableKind;
    }
    if (内容.length >= 4 && ((内容[0] == 字符_.u || 内容[0] == 字符_.s) && 内容[1] == 字符_.数_0 && 内容[2] == 字符_.x) && 是十六进制字符(内容[3])) {
        dstring 数字内容 = 内容[3 .. $];
        if (!.文本是十六进制的(数字内容)) {
            return ISK.Error;
        }
        if (内容[0] == 字符_.s) {
            .整数标志 |= (cast(整数_)(节点标志_.是有符号的_));
        }
        .整数标志 |= (cast(整数_)(节点标志_.US十六进制_));
        .APSIntVal = 数字内容;
        return ISK.APSInt;
    }
    if (内容.length >= 2 && 内容[0] == cast(dchar)'c' && 内容[1] == cast(dchar)'c') {
        dstring 数字内容 = 内容[2 .. $];
        if (!.文本是十进制的(数字内容)) {
            return ISK.Error;
        }
        .APSIntVal = 数字内容;
        return ISK.cc;
    }
    return ISK.Error;
}
bool 可以编译分号() {
    if (.令牌() == ISK.分号) {
        return true;
    }
    return .令牌() == ISK.右大括号 || .令牌() == ISK.文件结尾 || .前面有换行符();
}
基础节点.节点数组_!(IR节点_) 编译源文件平台() {
    return .编译源码顶级语句();
}
基础节点.节点数组_!(IR节点_) 编译源码顶级语句() {
    IR节点_[] 语句组 = 创建数组!(IR节点_)();
    while(.当前() != ISK.文件结尾) {
        switch (.当前()) {
            case ISK.target: {
                long 开始 = .获取节点开始();
                IR节点_ 设置值 = .parseTargetDefinition();
                ··IR节点_.目标语句_ n = 工厂.创建目标语句(设置值);
                n = .完成节点!(··IR节点_.目标语句_)(n, 开始);
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.source_filename: {
                long 开始 = .获取节点开始();
                .下个();
                .编译确定的(ISK.等号);
                IR文本字面量_ 设置值 = .parseStringConstant();
                ··IR节点_.源码文件名语句_ n = 工厂.创建源码文件名语句(设置值);
                n = .完成节点!(··IR节点_.源码文件名语句_)(n, 开始);
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.define: {
                函数定义_ n = .parseDefine();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.module_: {
                模块级汇编_ n = .parseModuleAsm();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.declare: {
                函数声明_ n = .parseDeclare();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.LocalVarID: {
                IR节点_ n = .parseUnnamedType();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.LocalVar: {
                IR节点_ n = .parseNamedType();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.GlobalID: {
                IR节点_ n = .parseUnnamedGlobal();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.GlobalVar: {
                IR节点_ n = .parseNamedGlobal();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.ComdatVar: {
                封装声明_ n = .parseComdat();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.叹号: {
                独立元数据_ n = .parseStandaloneMetadata();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.MetadataVar: {
                元数据声明_ n = .parseNamedMetadata();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.attributes: {
                特性声明_ n = .parseUnnamedAttrGrp();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.uselistorder: {
                用户历史数据_ n = .parseUseListOrder();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.uselistorder_bb: {
                用户历史数据_基本块_ n = .parseUseListOrderBB();
                .追加!(IR节点_)(语句组, n);
                continue;
            }
            case ISK.SummaryID: {
                if (.跳过摘要) {
                    .parseSummaryEntry();
                    continue;
                }
                else {
                    IR节点_ n = .parseSummaryEntry();
                    .追加!(IR节点_)(语句组, n);
                    continue;
                }
            }
            default: break;
        }
    }
    基础节点.节点数组_!(IR节点_) 文件语句 = .创建节点数组!(IR节点_)(语句组, 0);
    return 文件语句;
}
IR节点_ parseGlobalValue() {
    return .parseValID();
}
IR节点_ parseGlobalType() {
    IR节点_ 值;
    if (.当前() == ISK.constant || .当前() == ISK.global) {
        值 = .编译IR令牌节点(.当前());
    }
    else {
        值 = .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.缺少必须的_0_设置, "global' or 'constant"d);
    }
    return 值;
}
本地线程设置_ parseOptionalThreadLocal() {
    long 开始 = .获取节点开始();
    if (.编译可选的(ISK.thread_local)) {
        if (.编译可选的(ISK.左括号)) {
            IR节点_ 值 = .parseTLSModel();
            .编译确定的(ISK.右括号);
            本地线程设置_ n = 工厂.创建本地线程设置(值);
            return .完成节点!(本地线程设置_)(n, 开始);
        }
    }
    return ··null!(本地线程设置_);
}
IR节点_ parseTLSModel() {
    switch (.当前()) {
        case ISK.localdynamic:
        case ISK.initialexec:
        case ISK.localexec: {
            return .编译IR令牌节点(.当前());
        }
        default: {
            return .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.expected_localdynamic_initialexec_or_localexec);
        }
    }
}
用户历史数据_基本块_ parseUseListOrderBB() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.uselistorder_bb);
    IR节点_ Fn = .parseValID();
    .编译确定的(ISK.逗号);
    IR节点_ Label = .parseValID();
    .编译确定的(ISK.逗号);
    基础节点.节点数组_!(IR节点_) Indexes = .parseUseListOrderIndexes();
    用户历史数据_基本块_ n = 工厂.创建用户历史数据_基本块(Fn, Label, Indexes);
    return .完成节点!(用户历史数据_基本块_)(n, 开始);
}
特性声明_ parseUnnamedAttrGrp() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.attributes);
    IR数字字面量_ VarID = .getUIntVal();
    .编译确定的(ISK.等号);
    基础节点.节点数组_!(IR节点_) 成员 = .parseFnAttributeValuePairs(true);
    IR标识符_ name = 工厂.创建IR标识符(标识符分类_.特性标识符_ | 标识符分类_.ID标识符_, VarID);
    特性声明_ n = 工厂.创建特性声明(name, 成员);
    return .完成节点!(特性声明_)(n, 开始);
}
封装声明_ parseComdat() {
    long 开始 = .获取节点开始();
    IR文本字面量_ Name = .getStrVal();
    .编译确定的(ISK.等号);
    .编译确定的(ISK.comdat);
    IR节点_ 值;
    switch (.当前()) {
        case ISK.any:
        case ISK.exactmatch:
        case ISK.largest:
        case ISK.noduplicates:
        case ISK.samesize: {
            值 = .编译IR令牌!(ISK)(.当前());
            break;
        }
        default: {
            值 = .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.unknown_selection_kind);
        }
    }
    IR标识符_ name = 工厂.创建IR标识符(.获取标识符分类(Name, 标识符分类_.封装标识符_), Name);
    封装声明_ n = 工厂.创建封装声明(name, 值);
    return .完成节点!(封装声明_)(n, 开始);
}
标识符分类_ 获取标识符分类(IR文本字面量_ Id, 标识符分类_ 分类) {
    return (Id.标志 & 节点标志_.是文本内容_) != 0 ? 标识符分类_.文本内容标识符_ | 分类 : 分类;
}
IR节点_ parseNamedType() {
    long 开始 = .获取节点开始();
    IR文本字面量_ n = .getStrVal();
    IR标识符_ Name = 工厂.创建IR标识符(.获取标识符分类(n, 标识符分类_.类型标识符_), n);
    .编译确定的(ISK.等号);
    .编译确定的(ISK.type);
    return .parseStructDefinition(Name);
}
IR节点_ parseUnnamedType() {
    long 开始 = .获取节点开始();
    IR数字字面量_ TypeID = .getUIntVal();
    .编译确定的(ISK.等号);
    .编译确定的(ISK.type);
    IR标识符_ name = 工厂.创建IR标识符(标识符分类_.类型标识符_, TypeID);
    return .parseStructDefinition(name);
}
类型声明_ parseStructDefinition(IR标识符_ Name) {
    long 开始 = .获取节点开始();
    if (.当前() == ISK.opaque) {
        IR节点_ Ty = .编译IR令牌节点(.当前());
        类型声明_ DecTy = 工厂.创建类型声明(Name, Ty);
        return .完成节点!(类型声明_)(DecTy, Name.开始);
    }
    long 开始2 = .获取节点开始();
    bool isPacked = .编译可选的(ISK.左尖括号);
    if (.当前() != ISK.左大括号) {
        // 不支持递归 及前向引用
        // 是其他类型的别名
        if (isPacked) {
            IR节点_ VTy = .parseArrayVectorType(开始2, true);
            类型声明_ DecVTy = 工厂.创建类型声明(Name, VTy);
            return .完成节点!(类型声明_)(DecVTy, Name.开始);
        }
        IR节点_ PTy = .parseType();
        类型声明_ DecPTy = 工厂.创建类型声明(Name, PTy);
        return .完成节点!(类型声明_)(DecPTy, Name.开始);
    }
    long 开始3 = .获取节点开始();
    基础节点.节点数组_!(IR节点_) 元素组 = .parseStructBody();
    结构类型_ Sty = 工厂.创建结构类型(元素组);
    Sty.是压缩的 = isPacked;
    Sty = .完成节点!(结构类型_)(Sty, 开始3);
    if (isPacked) {
        .编译确定的(ISK.右尖括号);
    }
    类型声明_ DecSty = 工厂.创建类型声明(Name, Sty);
    return .完成节点!(类型声明_)(DecSty, Name.开始);
}
模块级汇编_ parseModuleAsm() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.module_);
    .编译确定的(ISK.asm_);
    IR文本字面量_ AsmStr = .parseStringConstant();
    模块级汇编_ n = 工厂.创建模块级汇编(AsmStr);
    return .完成节点!(模块级汇编_)(n, 开始);
}
函数声明_ parseDeclare() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.declare);
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    long 数组开始 = .获取节点开始();
    while(.当前() == ISK.MetadataVar) {
        IR节点_ N = .parseMetadataAttachment();
        .追加!(IR节点_)(数据组, N);
    }
    基础节点.节点数组_!(IR节点_) 元数据组;
    if (数据组.length > 0) {
        元数据组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
    }
    函数头_ fn = .parseFunctionHeader();
    函数声明_ n = 工厂.创建函数声明(fn.参数列表, fn.返回类型, fn.name, fn.连接特性, fn.运行时抢占, fn.可见性, fn.DLL储存类, fn.调用约定, fn.返回类型特性, fn.未命名的地址, fn.地址空间, fn.函数特性, fn.段设置, fn.隔板设置, fn.函数封装, fn.对齐设置, fn.GC设置, fn.前缀设置, fn.序言设置, fn.个性设置, fn.IsVarArg, 元数据组);
    return .完成节点!(函数声明_)(n, 开始);
}
bool isValidDeclarationLinkage(IR节点_ link) {
    return link.目标种类 == ISK.extern_weak || link.目标种类 == ISK.external;
}
IR节点_ parseNamedGlobal() {
    long 开始 = .获取节点开始();
    IR文本字面量_ N = .getStrVal();
    IR标识符_ Name = 工厂.创建IR标识符(.获取标识符分类(N, 标识符分类_.全局标识符_), N);
    .编译确定的(ISK.等号);
    LinkKage_ link = .parseOptionalLinkage();
    IR节点_ LinkageAux = link.LinkageAux;
    IR节点_ DSOLocal = link.DSOLocal;
    IR节点_ Visibility = link.Visibility;
    IR节点_ DLLStorageClass = link.DLLStorageClass;
    本地线程设置_ ThreadLocal = .parseOptionalThreadLocal();
    IR节点_ UnnamedAddr = .parseOptionalUnnamedAddr();
    if (.当前() == ISK.alias_ || .当前() == ISK.ifunc) {
        IsAliasOrIfunc_ I = .parseAliasOrIFunc();
        IR节点_ n = 工厂.创建别名声明(I.IsAliasOrIfunc, I.Ty, Name, LinkageAux, DSOLocal, Visibility, DLLStorageClass, ThreadLocal, UnnamedAddr, I.Aliasee, I.IndirectSymbolAttrs);
        return .完成节点!(IR节点_)(n, 开始);
    }
    else {
        全局值_ G = .parseGlobal((LinkageAux is ··null!(IR节点_)) || !.isValidDeclarationLinkage(LinkageAux));
        IR节点_ n = 工厂.创建全局变量声明(G.Ty, G.GOrC, Name, LinkageAux, DSOLocal, Visibility, DLLStorageClass, ThreadLocal, UnnamedAddr, G.AddrSpace, G.IsExternallyInitialized, G.G, G.Section, G.Alignment, G.Partition, G.CD, G.函数特性, G.MDS);
        return .完成节点!(IR节点_)(n, 开始);
    }
}
IR节点_ parseUnnamedGlobal() {
    long 开始 = .获取节点开始();
    IR数字字面量_ N = .getUIntVal();
    IR标识符_ Name = 工厂.创建IR标识符(标识符分类_.全局标识符_, N);
    .编译确定的(ISK.等号);
    LinkKage_ link = .parseOptionalLinkage();
    IR节点_ LinkageAux = link.LinkageAux;
    IR节点_ DSOLocal = link.DSOLocal;
    IR节点_ Visibility = link.Visibility;
    IR节点_ DLLStorageClass = link.DLLStorageClass;
    本地线程设置_ ThreadLocal = .parseOptionalThreadLocal();
    IR节点_ UnnamedAddr = .parseOptionalUnnamedAddr();
    if (.当前() == ISK.alias_ || .当前() == ISK.ifunc) {
        IsAliasOrIfunc_ I = .parseAliasOrIFunc();
        IR节点_ n = 工厂.创建别名声明(I.IsAliasOrIfunc, I.Ty, Name, LinkageAux, DSOLocal, Visibility, DLLStorageClass, ThreadLocal, UnnamedAddr, I.Aliasee, I.IndirectSymbolAttrs);
        return .完成节点!(IR节点_)(n, 开始);
    }
    else {
        全局值_ G = .parseGlobal((LinkageAux is ··null!(IR节点_)) || !.isValidDeclarationLinkage(LinkageAux));
        IR节点_ n = 工厂.创建全局变量声明(G.Ty, G.GOrC, Name, LinkageAux, DSOLocal, Visibility, DLLStorageClass, ThreadLocal, UnnamedAddr, G.AddrSpace, G.IsExternallyInitialized, G.G, G.Section, G.Alignment, G.Partition, G.CD, G.函数特性, G.MDS);
        return .完成节点!(IR节点_)(n, 开始);
    }
}
IsAliasOrIfunc_ parseAliasOrIFunc() {
    IR节点_ IsAliasOrIfunc;
    if (.当前() == ISK.alias_) {
        IsAliasOrIfunc = .编译IR令牌节点(ISK.alias_);
    }
    else {
        IsAliasOrIfunc = .编译IR令牌节点(ISK.ifunc);
    }
    IR节点_ Ty = .parseType(false);
    .编译确定的(ISK.逗号);
    ISK k = .当前();
    IR节点_ Aliasee;
    if (k != ISK.bitcast && k != ISK.getelementptr && k != ISK.addrspacecast && k != ISK.inttoptr) {
        Aliasee = .parseGlobalTypeAndValue();
    }
    else {
        Aliasee = .parseValID();
    }
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    long 数组开始 = 0;
    while(.当前() == ISK.逗号) {
        .编译确定的(ISK.逗号);
        if (数组开始 == 0) {
            数组开始 = .获取节点开始();
        }
        if (.当前() == ISK.partition) {
            .编译确定的(ISK.partition);
            IR文本字面量_ partition = .getStrVal();
            .追加!(IR节点_)(数据组, partition);
        }
        break;
    }
    基础节点.节点数组_!(IR节点_) IndirectSymbolAttrs = .创建节点数组!(IR节点_)(数据组, 数组开始);
    return .IsAliasOrIfunc_(IsAliasOrIfunc, Ty, Aliasee, IndirectSymbolAttrs);
}
全局值_ parseGlobal(bool 应该有初始) {
    地址空间设置_ AddrSpace = .parseOptionalAddrSpace();
    IR节点_ IsExternallyInitialized;
    if (.当前() == ISK.externally_initialized) {
        IsExternallyInitialized = .编译IR令牌节点(.当前());
    }
    IR节点_ GOrC = .parseGlobalType();
    IR节点_ Ty = .parseType();
    IR节点_ G;
    if (应该有初始) {
        G = .parseGlobalValue();
    }
    IR节点_ Section;
    IR节点_ Alignment;
    IR节点_ Partition;
    long 数组开始 = -1;
    IR节点_[] MD = 创建数组!(IR节点_)();
    IR节点_ CD;
    while(.编译可选的(ISK.逗号)) {
        if (.当前() == ISK.section) {
            .下个();
            Section = .getStrVal();
        }
        else if (.当前() == ISK.partition) {
            .下个();
            Partition = .getStrVal();
        }
        else if (.当前() == ISK.align_) {
            Alignment = .parseOptionalAlignment();
        }
        else if (.当前() == ISK.MetadataVar) {
            if (数组开始 == -1) {
                数组开始 = .获取节点开始();
            }
            IR节点_ md = .parseGlobalObjectMetadataAttachment();
            .追加!(IR节点_)(MD, md);
        }
        else {
            CD = .parseOptionalComdat();
        }
    }
    基础节点.节点数组_!(IR节点_) MDS;
    if (MD.length > 0) {
        IR节点_ L = MD[MD.length - 1];
        MDS = .创建节点数组!(IR节点_)(MD, 数组开始, L.结束);
    }
    基础节点.节点数组_!(IR节点_) FnAttrs = .parseFnAttributeValuePairs();
    return .全局值_(Ty, GOrC, AddrSpace, IsExternallyInitialized, G, Section, Alignment, Partition, MDS, CD, FnAttrs);
}
函数定义_ parseDefine() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.define);
    函数头_ Fn = .parseFunctionHeader();
    基础节点.节点数组_!(IR节点_) Md = .parseOptionalFunctionMetadata();
    函数体_ Fb = .parseFunctionBody();
    函数定义_ n = 工厂.创建函数定义(Fn.参数列表, Fn.返回类型, Fb, Fn.name, Fn.连接特性, Fn.运行时抢占, Fn.可见性, Fn.DLL储存类, Fn.调用约定, Fn.返回类型特性, Fn.未命名的地址, Fn.地址空间, Fn.函数特性, Fn.段设置, Fn.隔板设置, Fn.函数封装, Fn.对齐设置, Fn.GC设置, Fn.前缀设置, Fn.序言设置, Fn.个性设置, Fn.IsVarArg, Md);
    return .完成节点!(函数定义_)(n, 开始);
}
函数头_ parseFunctionHeader() {
    long 开始 = .获取节点开始();
    LinkKage_ link = .parseOptionalLinkage();
    IR节点_ LinkageAux = link.LinkageAux;
    IR节点_ DSOLocal = link.DSOLocal;
    IR节点_ Visibility = link.Visibility;
    IR节点_ DLLStorageClass = link.DLLStorageClass;
    IR节点_ CC = .parseOptionalCallingConv();
    基础节点.节点数组_!(IR节点_) RetAttrs = .parseOptionalReturnAttrs();
    IR节点_ Ty = .parseType(true);
    IR标识符_ Name;
    if (.当前() == ISK.GlobalVar) {
        IR文本字面量_ N = .getStrVal();
        Name = 工厂.创建IR标识符(.获取标识符分类(N, 标识符分类_.函数名称_), N);
    }
    else if (.当前() == ISK.GlobalID) {
        IR数字字面量_ N = .getUIntVal();
        Name = 工厂.创建IR标识符(标识符分类_.函数名称_ | 标识符分类_.ID标识符_, N);
    }
    bool IsVarArg = false;
    基础节点.节点数组_!(IR节点_) ArgList = .parseArgumentList(IsVarArg);
    IR节点_ Addr = .parseOptionalUnnamedAddr();
    地址空间设置_ AddrSpace = .parseOptionalAddrSpace();
    基础节点.节点数组_!(IR节点_) FnAttrs = .parseFnAttributeValuePairs(false);
    IR节点_ Section;
    if (.编译可选的(ISK.section)) {
        Section = .parseStringConstant();
    }
    IR节点_ Partition;
    if (.编译可选的(ISK.partition)) {
        Partition = .parseStringConstant();
    }
    IR节点_ Comd = .parseOptionalComdat();
    对齐设置_ Align = .parseOptionalAlignment();
    IR节点_ Gc;
    if (.编译可选的(ISK.gc)) {
        Gc = .parseStringConstant();
    }
    全局表达式_ Prefix;
    if (.编译可选的(ISK.prefix)) {
        Prefix = .parseGlobalTypeAndValue();
    }
    全局表达式_ Prologue;
    if (.编译可选的(ISK.prologue)) {
        Prologue = .parseGlobalTypeAndValue();
    }
    全局表达式_ Personality;
    if (.编译可选的(ISK.personality)) {
        Personality = .parseGlobalTypeAndValue();
    }
    函数头_ 函数头 = .函数头_(ArgList, Ty, Name, LinkageAux, DSOLocal, Visibility, DLLStorageClass, CC, RetAttrs, Addr, AddrSpace, FnAttrs, Section, Partition, Comd, Align, Gc, Prefix, Prologue, Personality, IsVarArg);
    return 函数头;
}
函数体_ parseFunctionBody() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.左大括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    while(.当前() != ISK.右大括号 && .当前() != ISK.uselistorder) {
        .追加!(IR节点_)(数据组, .parseBasicBlock());
    }
    基础节点.节点数组_!(IR节点_) 基本块组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
    用户历史数据_ 用户数据;
    while(.当前() != ISK.右大括号) {
        用户数据 = .parseUseListOrder();
    }
    .编译确定的(ISK.右大括号);
    函数体_ n = 工厂.创建函数体(基本块组, 用户数据);
    return .完成节点!(函数体_)(n, 开始);
}
块声明_ parseBasicBlock() {
    long 块开始 = .获取节点开始();
    IR标识符_ Name;
    IR标识符_ NameID;
    if (.当前() == ISK.LabelStr) {
        IR文本字面量_ name = .getStrVal();
        Name = 工厂.创建IR标识符(.获取标识符分类(name, 标识符分类_.标签标识符_), name);
    }
    else if (.当前() == ISK.LabelID) {
        IR数字字面量_ name = .getUIntVal();
        NameID = 工厂.创建IR标识符(标识符分类_.标签标识符_ | 标识符分类_.ID标识符_, name);
    }
    IR节点_[] 语句组 = 创建数组!(IR节点_)();
    long 数组开始 = .获取节点开始();
    while(true) {
        IR标识符_ ID;
        IR标识符_ NS;
        if (.当前() == ISK.LocalVarID) {
            IR数字字面量_ id = .getUIntVal();
            ID = 工厂.创建IR标识符(标识符分类_.局部标识符_ | 标识符分类_.ID标识符_, id);
            .编译确定的(ISK.等号);
        }
        else if (.当前() == ISK.LocalVar) {
            IR文本字面量_ ns = .getStrVal();
            NS = 工厂.创建IR标识符(.获取标识符分类(ns, 标识符分类_.局部标识符_), ns);
            .编译确定的(ISK.等号);
        }
        IR节点_ Inst = .parseInstruction();
        // 这里错误了;
        if (是局部声明语句(Inst)) {
            IR标识符_ nn = ID ? ID : NS;
            局部变量声明_ dec = 工厂.创建局部变量声明(nn, Inst);
            Inst = .完成节点!(局部变量声明_)(dec, nn.开始);
        }
        .追加!(IR节点_)(语句组, Inst);
        if (.是终结指令(Inst)) {
            break;
        }
    }
    基础节点.节点数组_!(IR节点_) 块语句 = .创建节点数组!(IR节点_)(语句组, 数组开始);
    块声明_ n = 工厂.创建块声明(NameID ? NameID : Name, 块语句);
    return .完成节点!(块声明_)(n, 块开始);
}
bool 是终结指令(IR节点_ Inst) {
    if (Inst.目标种类 == ISK.局部变量声明) {
        return .是终结指令((cast(局部变量声明_)(Inst)).初始化);
    }
    switch (Inst.目标种类) {
        case ISK.不及指令:
        case ISK.返回指令:
        case ISK.跳转指令:
        case ISK.假如指令:
        case ISK.直接跳转指令:
        case ISK.唤出指令:
        case ISK.重启指令:
        case ISK.清理返回指令:
        case ISK.捕获返回指令:
        case ISK.捕获分支指令:
        case ISK.调用跳转指令: {
            return true;
        }
        default: break;
    }
    return false;
}
用户历史数据_ parseUseListOrder() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.uselistorder);
    值表达式_ V = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    基础节点.节点数组_!(IR节点_) Indexes = .parseUseListOrderIndexes();
    用户历史数据_ n = 工厂.创建用户历史数据(V, Indexes);
    return .完成节点!(用户历史数据_)(n, 开始);
}
基础节点.节点数组_!(IR节点_) parseUseListOrderIndexes() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.左大括号);
    long 数组开始 = .获取节点开始();
    bool 第一层 = false;
    IR节点_[] indexs = 创建数组!(IR节点_)();
    while(!第一层 || .编译可选的(ISK.逗号)) {
        第一层 = true;
        IR数字字面量_ Index = .parseUInt32();
        .追加!(IR节点_)(indexs, Index);
    }
    基础节点.节点数组_!(IR节点_) 索引表 = .创建节点数组!(IR节点_)(indexs, 数组开始);
    .编译确定的(ISK.右大括号);
    return 索引表;
}
IR节点_ parseInstruction() {
    ISK Token = .当前();
    switch (Token) {
        // Terminator Instructions.
        case ISK.unreachable: {
            return .parseUnreachableInst();
        }
        case ISK.ret: {
            return .parseRet();
        }
        case ISK.br: {
            return .parseBr();
        }
        case ISK.switch_: {
            return .parseSwitch();
        }
        case ISK.indirectbr: {
            return .parseIndirectBr();
        }
        case ISK.invoke: {
            return .parseInvoke();
        }
        case ISK.resume: {
            return .parseResume();
        }
        case ISK.cleanupret: {
            return .parseCleanupRet();
        }
        case ISK.catchret: {
            return .parseCatchRet();
        }
        case ISK.catchswitch: {
            return .parseCatchSwitch();
        }
        case ISK.catchpad: {
            return .parseCatchPad();
        }
        case ISK.cleanuppad: {
            return .parseCleanupPad();
        }
        case ISK.callbr: {
            return .parseCallBr();
        }
        // Unary Operators.
        case ISK.fneg: {
            return .parseUnaryOp();
        }
        case ISK.add:
        case ISK.sub:
        case ISK.mul:
        case ISK.shl:
        case ISK.fadd:
        case ISK.fsub:
        case ISK.fmul:
        case ISK.fdiv:
        case ISK.sdiv:
        case ISK.udiv:
        case ISK.lshr:
        case ISK.ashr:
        case ISK.urem:
        case ISK.srem: {
            return .parseArithmetic();
        }
        case ISK.and:
        case ISK.or:
        case ISK.xor: {
            return .parseLogical();
        }
        case ISK.icmp:
        case ISK.fcmp: {
            return .parseCompare();
        }
        case ISK.trunc:
        case ISK.zext:
        case ISK.sext:
        case ISK.fptrunc:
        case ISK.fpext:
        case ISK.bitcast:
        case ISK.addrspacecast:
        case ISK.uitofp:
        case ISK.sitofp:
        case ISK.fptoui:
        case ISK.fptosi:
        case ISK.inttoptr:
        case ISK.ptrtoint: {
            return .parseCast();
        }
        case ISK.select: {
            return .parseSelect();
        }
        case ISK.va_arg: {
            return .parseVAArg();
        }
        case ISK.extractelement: {
            return .parseExtractElement();
        }
        case ISK.insertelement: {
            return .parseInsertElement();
        }
        case ISK.shufflevector: {
            return .parseShuffleVector();
        }
        case ISK.phi: {
            return .parsePHI();
        }
        case ISK.landingpad: {
            return .parseLandingPad();
        }
        case ISK.freeze: {
            return .parseFreeze();
        }
        case ISK.call:
        case ISK.tail:
        case ISK.musttail:
        case ISK.notail: {
            return .parseCall();
        }
        case ISK.alloca: {
            return .parseAlloc();
        }
        case ISK.load: {
            return .parseLoad();
        }
        case ISK.store: {
            return .parseStore();
        }
        case ISK.cmpxchg: {
            return .parseCmpXchg();
        }
        case ISK.atomicrmw: {
            return .parseAtomicRMW();
        }
        case ISK.fence: {
            return .parseFence();
        }
        case ISK.getelementptr: {
            return .parseGetElementPtr();
        }
        case ISK.extractvalue: {
            return .parseExtractValue();
        }
        case ISK.insertvalue: {
            return .parseInsertValue();
        }
        default: break;
    }
    return .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.未知指令_0);
}
IR节点_ parseUnreachableInst() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.unreachable);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    不及指令_ n = 工厂.创建不及指令(尾部数据);
    return .完成节点!(不及指令_)(n, 开始);
}
返回指令_ parseRet() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.ret);
    long 表达式开始 = .获取节点开始();
    IR节点_ 类型 = .parseType(true);
    返回指令_ n;
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (类型.目标种类 == ISK.void_) {
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
        n = 工厂.创建返回指令(返回零值!(值表达式_)(), 尾部数据);
        return .完成节点!(返回指令_)(n, 开始);
    }
    IR节点_ 值 = .parseValue();
    值表达式_ 值表达式 = 工厂.创建值表达式(类型, 值);
    值表达式 = .完成节点!(值表达式_)(值表达式, 表达式开始);
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    n = 工厂.创建返回指令(值表达式, 尾部数据);
    return .完成节点!(返回指令_)(n, 开始);
}
跳转指令_ parseBr() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.br);
    值表达式_ Op0 = .parseTypeAndValue();
    if (Op0.类型.目标种类 == ISK.label) {
        基础节点.节点数组_!(IR节点_) 尾部数据;
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
        跳转指令_ n = 工厂.创建跳转指令(Op0, 尾部数据);
        return .完成节点!(跳转指令_)(n, 开始);
    }
    .编译确定的(ISK.逗号);
    值表达式_ Op1 = .parseTypeAndBasicBlock();
    .编译确定的(ISK.逗号);
    值表达式_ Op2 = .parseTypeAndBasicBlock();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    跳转指令_ n = 工厂.创建跳转指令(Op1, 尾部数据, Op0, Op2);
    return .完成节点!(跳转指令_)(n, 开始);
}
假如指令_ parseSwitch() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.switch_);
    值表达式_ Cond = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ DefaultBB = .parseTypeAndBasicBlock();
    .编译确定的(ISK.左方括号);
    long 数组开始 = .获取节点开始();
    跳转表元素_[] 数据组 = 创建数组!(跳转表元素_)();
    while(.当前() != ISK.右方括号) {
        long 元素开始 = .获取节点开始();
        值表达式_ Constant = .parseTypeAndValue();
        .编译确定的(ISK.逗号);
        值表达式_ DestBB = .parseTypeAndBasicBlock();
        跳转表元素_ nn = 工厂.创建跳转表元素(Constant, DestBB);
        nn = .完成节点!(跳转表元素_)(nn, 元素开始);
        .追加!(跳转表元素_)(数据组, nn);
    }
    基础节点.节点数组_!(跳转表元素_) 跳转表 = .创建节点数组!(跳转表元素_)(数据组, 数组开始);
    .编译确定的(ISK.右方括号);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    假如指令_ n = 工厂.创建假如指令(Cond, DefaultBB, 跳转表, 尾部数据);
    return .完成节点!(假如指令_)(n, 开始);
}
直接跳转指令_ parseIndirectBr() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.indirectbr);
    值表达式_ Address = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    .编译确定的(ISK.左方括号);
    long 数组开始 = .获取节点开始();
    值表达式_[] 数据组 = 创建数组!(值表达式_)();
    if (.当前() != ISK.右方括号) {
        值表达式_ DestBB = .parseTypeAndBasicBlock();
        .追加!(值表达式_)(数据组, DestBB);
        while(.编译可选的(ISK.逗号)) {
            DestBB = .parseTypeAndBasicBlock();
            .追加!(值表达式_)(数据组, DestBB);
        }
    }
    基础节点.节点数组_!(值表达式_) 跳转表 = .创建节点数组!(值表达式_)(数据组, 数组开始);
    .编译确定的(ISK.右方括号);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    直接跳转指令_ n = 工厂.创建直接跳转指令(Address, 跳转表, 尾部数据);
    return .完成节点!(直接跳转指令_)(n, 开始);
}
唤出指令_ parseInvoke() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.invoke);
    IR节点_ CC = .parseOptionalCallingConv();
    基础节点.节点数组_!(IR节点_) RetAttrs = .parseOptionalReturnAttrs();
    地址空间设置_ InvokeAddrSpace = .parseOptionalProgramAddrSpace();
    IR节点_ RetType = .parseType(true);
    IR节点_ CalleeID = .parseValID();
    基础节点.节点数组_!(IR节点_) ArgList = .parseParameterList();
    基础节点.节点数组_!(IR节点_) FnAttrs = .parseFnAttributeValuePairs();
    操作数标签组_ BundleList = .parseOptionalOperandBundles();
    .编译确定的(ISK.to);
    值表达式_ NormalBB = .parseTypeAndBasicBlock();
    .编译确定的(ISK.unwind);
    值表达式_ UnwindBB = .parseTypeAndBasicBlock();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    唤出指令_ n = 工厂.创建唤出指令(CalleeID, RetType, NormalBB, UnwindBB, RetAttrs, ArgList, FnAttrs, BundleList, CC, InvokeAddrSpace, 尾部数据);
    return .完成节点!(唤出指令_)(n, 开始);
}
重启指令_ parseResume() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.resume);
    值表达式_ Exn = .parseTypeAndValue();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    重启指令_ n = 工厂.创建重启指令(Exn, 尾部数据);
    return .完成节点!(重启指令_)(n, 开始);
}
清理返回指令_ parseCleanupRet() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.cleanupret);
    .编译确定的(ISK.from);
    IR节点_ CleanupPad = .parseValue();
    .编译确定的(ISK.unwind);
    值表达式_ UnwindBB;
    if (.编译可选的(ISK.to)) {
        .编译确定的(ISK.caller);
    }
    else {
        UnwindBB = .parseTypeAndBasicBlock();
    }
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    清理返回指令_ n = 工厂.创建清理返回指令(CleanupPad, UnwindBB, 尾部数据);
    return .完成节点!(清理返回指令_)(n, 开始);
}
捕获返回指令_ parseCatchRet() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.catchret);
    .编译确定的(ISK.from);
    IR节点_ CatchPad = .parseValue();
    .编译确定的(ISK.to);
    值表达式_ BB = .parseTypeAndBasicBlock();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    捕获返回指令_ n = 工厂.创建捕获返回指令(CatchPad, BB, 尾部数据);
    return .完成节点!(捕获返回指令_)(n, 开始);
}
捕获分支指令_ parseCatchSwitch() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.catchswitch);
    .编译确定的(ISK.within);
    IR节点_ ParentPad = .parseValue();
    .编译确定的(ISK.左方括号);
    bool 第一层 = false;
    long 数组开始 = .获取节点开始();
    值表达式_[] 数据组 = 创建数组!(值表达式_)();
    while(!第一层 || .编译可选的(ISK.逗号)) {
        第一层 = true;
        值表达式_ DestBB = .parseTypeAndBasicBlock();
        .追加!(值表达式_)(数据组, DestBB);
    }
    基础节点.节点数组_!(值表达式_) Table = .创建节点数组!(值表达式_)(数据组, 数组开始);
    .编译确定的(ISK.右方括号);
    .编译确定的(ISK.unwind);
    值表达式_ UnwindBB;
    if (.编译可选的(ISK.to)) {
        .编译确定的(ISK.caller);
    }
    else {
        UnwindBB = .parseTypeAndBasicBlock();
    }
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    捕获分支指令_ n = 工厂.创建捕获分支指令(ParentPad, ·to!(基础节点.节点数组_!(IR节点_))(Table), UnwindBB, 尾部数据);
    return .完成节点!(捕获分支指令_)(n, 开始);
}
捕获场指令_ parseCatchPad() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.catchpad);
    .编译确定的(ISK.within);
    IR节点_ CatchSwitch = .parseValue();
    基础节点.节点数组_!(IR节点_) Args = .parseExceptionArgs();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    捕获场指令_ n = 工厂.创建捕获场指令(CatchSwitch, Args, 尾部数据);
    return .完成节点!(捕获场指令_)(n, 开始);
}
基础节点.节点数组_!(IR节点_) parseExceptionArgs() {
    .编译确定的(ISK.左方括号);
    long 开始 = .获取节点开始();
    IR节点_[] Args = 创建数组!(IR节点_)();
    while(.当前() != ISK.右方括号) {
        if (Args.length != 0) {
            .编译确定的(ISK.逗号);
        }
        long 实参开始 = .获取节点开始();
        IR节点_ ArgTy = .parseType();
        IR节点_ V;
        if (ArgTy.目标种类 == ISK.metadata) {
            V = .parseMetadataAsValue();
        }
        else {
            V = .parseValue();
        }
        值表达式_ nn = 工厂.创建值表达式(ArgTy, V);
        nn = .完成节点!(值表达式_)(nn, 实参开始);
        .追加!(IR节点_)(Args, nn);
    }
    基础节点.节点数组_!(IR节点_) 实参组 = .创建节点数组!(IR节点_)(Args, 开始);
    .编译确定的(ISK.右方括号);
    return 实参组;
}
清理场指令_ parseCleanupPad() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.cleanuppad);
    .编译确定的(ISK.within);
    IR节点_ ParentPad = .parseValue();
    基础节点.节点数组_!(IR节点_) Args = .parseExceptionArgs();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    清理场指令_ n = 工厂.创建清理场指令(ParentPad, Args, 尾部数据);
    return .完成节点!(清理场指令_)(n, 开始);
}
调用跳转指令_ parseCallBr() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.callbr);
    IR节点_ CC = .parseOptionalCallingConv();
    基础节点.节点数组_!(IR节点_) RetAttrs = .parseOptionalReturnAttrs();
    IR节点_ RetType = .parseType(true);
    IR节点_ CalleeID = .parseValID();
    基础节点.节点数组_!(IR节点_) ArgList = .parseParameterList();
    基础节点.节点数组_!(IR节点_) FnAttrs = .parseFnAttributeValuePairs();
    操作数标签组_ BundleList = .parseOptionalOperandBundles();
    .编译确定的(ISK.to);
    值表达式_ DefaultDest = .parseTypeAndBasicBlock();
    .编译确定的(ISK.左方括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    if (.当前() != ISK.右方括号) {
        值表达式_ DestBB = .parseTypeAndBasicBlock();
        .追加!(IR节点_)(数据组, DestBB);
        while(.编译可选的(ISK.逗号)) {
            DestBB = .parseTypeAndBasicBlock();
            .追加!(IR节点_)(数据组, DestBB);
        }
    }
    基础节点.节点数组_!(IR节点_) IndirectDests = .创建节点数组!(IR节点_)(数据组, 数组开始);
    .编译确定的(ISK.右方括号);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    调用跳转指令_ n = 工厂.创建调用跳转指令(CalleeID, RetType, DefaultDest, IndirectDests, ArgList, CC, RetAttrs, FnAttrs, BundleList, 尾部数据);
    return .完成节点!(调用跳转指令_)(n, 开始);
}
取反指令_ parseUnaryOp() {
    long 开始 = .获取节点开始();
    .编译IR令牌节点(.当前());
    基础节点.节点数组_!(IR节点_) 快速标志 = .EatFastMathFlagsIfPresent();
    值表达式_ LHS = .parseTypeAndValue();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    取反指令_ n = 工厂.创建取反指令(LHS, 快速标志, 尾部数据);
    return .完成节点!(取反指令_)(n, 开始);
}
基础节点.节点数组_!(IR节点_) EatFastMathFlagsIfPresent() {
    long 数组开始 = .获取节点开始();
    IR节点_[] ns = 创建数组!(IR节点_)();
    bool T = true;
    循环标签: while(T) {
        switch (.当前()) {
            case ISK.fast:
            case ISK.nnan:
            case ISK.ninf:
            case ISK.nsz:
            case ISK.arcp:
            case ISK.contract:
            case ISK.reassoc:
            case ISK.afn: {
                IR节点_ n = .编译IR令牌节点(.当前());
                .追加!(IR节点_)(ns, n);
                continue;
            }
            default: {
                break 循环标签;
            }
        }
    }
    if (ns.length == 0) {
        return ··null!(基础节点.节点数组_!(IR节点_));
    }
    return .创建节点数组!(IR节点_)(ns, 数组开始);
}
IR节点_ parseArithmetic() {
    long 开始 = .获取节点开始();
    IR节点_ 指令 = .编译IR令牌节点(.当前());
    if (指令.目标种类 == ISK.add || 指令.目标种类 == ISK.sub || 指令.目标种类 == ISK.mul || 指令.目标种类 == ISK.shl) {
        IR节点_ NUW;
        IR节点_ NSW;
        IR节点_[] 标志组 = 创建数组!(IR节点_)();
        if (.当前() == ISK.nuw) {
            NUW = .编译IR令牌节点(.当前());
            .追加!(IR节点_)(标志组, NUW);
        }
        if (.当前() == ISK.nsw) {
            NSW = .编译IR令牌节点(.当前());
            .追加!(IR节点_)(标志组, NSW);
            if ((NUW is ··null!(IR节点_)) && .当前() == ISK.nuw) {
                NUW = .编译IR令牌节点(.当前());
                .追加!(IR节点_)(标志组, NUW);
            }
        }
        基础节点.节点数组_!(IR节点_) 数学标志组;
        if (标志组.length > 0) {
            IR节点_ n = 标志组[0];
            数学标志组 = .创建节点数组!(IR节点_)(标志组, n.开始);
        }
        值表达式_ LHS = .parseTypeAndValue();
        .编译确定的(ISK.逗号);
        IR节点_ RHS = .parseValue();
        基础节点.节点数组_!(IR节点_) 尾部数据;
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
        IR节点_ n = 工厂.创建整数和差积及左移指令(指令, LHS, RHS, 数学标志组, 尾部数据);
        return .完成节点!(IR节点_)(n, 开始);
    }
    else if (指令.目标种类 == ISK.fadd || 指令.目标种类 == ISK.fsub || 指令.目标种类 == ISK.fmul || 指令.目标种类 == ISK.fdiv || 指令.目标种类 == ISK.frem) {
        基础节点.节点数组_!(IR节点_) FMF = .EatFastMathFlagsIfPresent();
        值表达式_ LHS = .parseTypeAndValue();
        .编译确定的(ISK.逗号);
        IR节点_ RHS = .parseValue();
        基础节点.节点数组_!(IR节点_) 尾部数据;
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
        IR节点_ n = 工厂.创建小数和差积及左移指令(指令, LHS, RHS, FMF, 尾部数据);
        return .完成节点!(IR节点_)(n, 开始);
    }
    else if (指令.目标种类 == ISK.sdiv || 指令.目标种类 == ISK.udiv || 指令.目标种类 == ISK.lshr || 指令.目标种类 == ISK.ashr) {
        IR节点_ Exact;
        if (.当前() == ISK.exact) {
            Exact = .编译IR令牌节点(.当前());
        }
        值表达式_ LHS = .parseTypeAndValue();
        .编译确定的(ISK.逗号);
        IR节点_ RHS = .parseValue();
        基础节点.节点数组_!(IR节点_) 尾部数据;
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
        IR节点_ n = 工厂.创建有无符号求商及右移指令(指令, LHS, RHS, Exact, 尾部数据);
        return .完成节点!(IR节点_)(n, 开始);
    }
    else {
        //指令.目标种类 == ISK.urem || 指令.目标种类 == ISK.srem
        值表达式_ LHS = .parseTypeAndValue();
        .编译确定的(ISK.逗号);
        IR节点_ RHS = .parseValue();
        基础节点.节点数组_!(IR节点_) 尾部数据;
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
        IR节点_ n = 工厂.创建有无符号求余数运算指令(指令, LHS, RHS, 尾部数据);
        return .完成节点!(IR节点_)(n, 开始);
    }
}
位运算指令_ parseLogical() {
    long 开始 = .获取节点开始();
    IR节点_ 指令 = .编译IR令牌节点(.当前());
    值表达式_ LHS = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    IR节点_ RHS = .parseValue();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    位运算指令_ n = 工厂.创建位运算指令(指令, LHS, RHS, 尾部数据);
    return .完成节点!(位运算指令_)(n, 开始);
}
比较运算指令_ parseCompare() {
    //  比较运算指令_
    long 开始 = .获取节点开始();
    ISK Opc = .当前();
    IR节点_ 指令 = .编译IR令牌节点(.当前());
    IR节点_ Pred = .parseCmpPredicate(Opc);
    值表达式_ LHS = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    IR节点_ RHS = .parseValue();
    基础节点.节点数组_!(IR节点_) FMF;
    if (Opc == ISK.fcmp) {
        FMF = .EatFastMathFlagsIfPresent();
    }
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    比较运算指令_ n = 工厂.创建比较运算指令(指令, LHS, RHS, Pred, FMF, 尾部数据);
    return .完成节点!(比较运算指令_)(n, 开始);
}
选择指令_ parseSelect() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.select);
    基础节点.节点数组_!(IR节点_) FMF = .EatFastMathFlagsIfPresent();
    值表达式_ Op0 = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ Op1 = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ Op2 = .parseTypeAndValue();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    选择指令_ n = 工厂.创建选择指令(Op0, Op1, Op2, FMF, 尾部数据);
    return .完成节点!(选择指令_)(n, 开始);
}
转换类指令_ parseCast() {
    long 开始 = .获取节点开始();
    IR节点_ 指令 = .编译IR令牌节点(.当前());
    值表达式_ Op = .parseTypeAndValue();
    .编译确定的(ISK.to);
    IR节点_ DestTy = .parseType();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    转换类指令_ n = 工厂.创建转换类指令(指令, Op, DestTy, 尾部数据);
    return .完成节点!(转换类指令_)(n, 开始);
}
可变参数指令_ parseVAArg() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.va_arg);
    值表达式_ Op = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    IR节点_ EltTy = .parseType();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    可变参数指令_ n = 工厂.创建可变参数指令(Op, EltTy, 尾部数据);
    return .完成节点!(可变参数指令_)(n, 开始);
}
提取元素指令_ parseExtractElement() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.extractelement);
    值表达式_ Op0 = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ Op1 = .parseTypeAndValue();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    提取元素指令_ n = 工厂.创建提取元素指令(Op0, Op1, 尾部数据);
    return .完成节点!(提取元素指令_)(n, 开始);
}
插入元素指令_ parseInsertElement() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.insertelement);
    值表达式_ Op0 = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ Op1 = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ Op2 = .parseTypeAndValue();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    插入元素指令_ n = 工厂.创建插入元素指令(Op0, Op1, Op2, 尾部数据);
    return .完成节点!(插入元素指令_)(n, 开始);
}
洗牌向量指令_ parseShuffleVector() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.shufflevector);
    值表达式_ Op0 = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ Op1 = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ Op2 = .parseTypeAndValue();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    洗牌向量指令_ n = 工厂.创建洗牌向量指令(Op0, Op1, Op2, 尾部数据);
    return .完成节点!(洗牌向量指令_)(n, 开始);
}
PHI节点指令_ parsePHI() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.phi);
    基础节点.节点数组_!(IR节点_) FMF = .EatFastMathFlagsIfPresent();
    IR节点_ Ty = .parseType();
    long 数组开始 = .获取节点开始();
    PHI节点元素_[] 元素组 = 创建数组!(PHI节点元素_)();
    .编译确定的(ISK.左方括号);
    IR节点_ Op0 = .parseValue();
    .编译确定的(ISK.逗号);
    IR节点_ Op1 = .parseValue();
    .编译确定的(ISK.右方括号);
    PHI节点元素_ ns = 工厂.创建PHI节点元素(Op0, Op1);
    ns = .完成节点!(PHI节点元素_)(ns, 数组开始);
    .追加!(PHI节点元素_)(元素组, ns);
    bool T = true;
    long 数组结束 = 0;
    while(T) {
        数组结束 = .获取节点开始();
        if (!.编译可选的(ISK.逗号)) {
            break;
        }
        if (.当前() == ISK.MetadataVar) {
            T = false;
            break;
        }
        long 元素开始 = .获取节点开始();
        .编译确定的(ISK.左方括号);
        IR节点_ Op2 = .parseValue();
        .编译确定的(ISK.逗号);
        IR节点_ Op3 = .parseValue();
        .编译确定的(ISK.右方括号);
        PHI节点元素_ ne = 工厂.创建PHI节点元素(Op2, Op3);
        ne = .完成节点!(PHI节点元素_)(ne, 数组开始);
        .追加!(PHI节点元素_)(元素组, ne);
    }
    基础节点.节点数组_!(PHI节点元素_) 节点组;
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (!T) {
        节点组 = .创建节点数组!(PHI节点元素_)(元素组, 数组开始, 数组结束);
        尾部数据 = .parseInstructionMetadata();
    }
    else {
        节点组 = .创建节点数组!(PHI节点元素_)(元素组, 数组开始);
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
    }
    PHI节点指令_ n = 工厂.创建PHI节点指令(Ty, 节点组, FMF, 尾部数据);
    return .完成节点!(PHI节点指令_)(n, 开始);
}
着陆场指令_ parseLandingPad() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.landingpad);
    IR节点_ Ty = .parseType();
    IR节点_ Cleanup;
    if (.当前() == ISK.cleanup) {
        Cleanup = .编译IR令牌节点(.当前());
    }
    long 数组开始 = .获取节点开始();
    捕获或过滤器_[] nss = 创建数组!(捕获或过滤器_)();
    while(.当前() == ISK.catch_ || .当前() == ISK.filter) {
        IR节点_ cf = .编译IR令牌节点(.当前());
        值表达式_ V = .parseTypeAndValue();
        捕获或过滤器_ ns = 工厂.创建捕获或过滤器(cf, V);
        ns.开始 = cf.开始;
        ns.结束 = V.结束;
        .追加!(捕获或过滤器_)(nss, ns);
    }
    基础节点.节点数组_!(捕获或过滤器_) 捕获或过滤器 = .创建节点数组!(捕获或过滤器_)(nss, 数组开始);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    着陆场指令_ n = 工厂.创建着陆场指令(Ty, 捕获或过滤器, Cleanup, 尾部数据);
    return .完成节点!(着陆场指令_)(n, 开始);
}
冻结指令_ parseFreeze() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.freeze);
    值表达式_ Op = .parseTypeAndValue();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    冻结指令_ n = 工厂.创建冻结指令(Op, 尾部数据);
    return .完成节点!(冻结指令_)(n, 开始);
}
调用指令_ parseCall() {
    long 开始 = .获取节点开始();
    ISK kind = .当前();
    IR节点_ tk;
    assert(kind == ISK.call || kind == ISK.tail || kind == ISK.musttail || kind == ISK.notail, "xxxx"c);
    if (kind != ISK.call) {
        tk = .编译IR令牌节点(kind);
    }
    .编译确定的(ISK.call);
    基础节点.节点数组_!(IR节点_) FMF = .EatFastMathFlagsIfPresent();
    IR节点_ CC = .parseOptionalCallingConv();
    基础节点.节点数组_!(IR节点_) RetAttrs = .parseOptionalReturnAttrs();
    地址空间设置_ CallAddrSpace = .parseOptionalProgramAddrSpace();
    IR节点_ RetType = .parseType(true);
    IR节点_ CalleeID = .parseValID();
    基础节点.节点数组_!(IR节点_) ArgList = .parseParameterList();
    基础节点.节点数组_!(IR节点_) FnAttrs = .parseFnAttributeValuePairs();
    操作数标签组_ BundleList = .parseOptionalOperandBundles();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    调用指令_ n = 工厂.创建调用指令(CalleeID, RetType, ArgList, tk, FMF, CallAddrSpace, CC, RetAttrs, FnAttrs, BundleList, 尾部数据);
    return .完成节点!(调用指令_)(n, 开始);
}
分配指令_ parseAlloc() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.alloca);
    IR节点_ IsInAlloca;
    if (.当前() == ISK.inalloca) {
        IsInAlloca = .编译IR令牌节点(.当前());
    }
    IR节点_ IsSwiftError;
    if (.当前() == ISK.swifterror) {
        IsSwiftError = .编译IR令牌节点(.当前());
    }
    IR节点_ Ty = .parseType();
    bool T = false;
    IR节点_ Alignment;
    IR节点_ AddrSpace;
    IR节点_ Size;
    if (.编译可选的(ISK.逗号)) {
        if (.当前() == ISK.align_) {
            Alignment = .parseOptionalAlignment();
            AddrSpace = .parseOptionalCommaAddrSpace(T);
        }
        else if (.当前() == ISK.addrspace) {
            AddrSpace = .parseOptionalCommaAddrSpace(T);
        }
        else if (.当前() == ISK.MetadataVar) {
            T = true;
        }
        else {
            Size = .parseTypeAndValue();
            if (.编译可选的(ISK.逗号)) {
                if (.当前() == ISK.align_) {
                    Alignment = .parseOptionalAlignment();
                    AddrSpace = .parseOptionalCommaAddrSpace(T);
                }
                else if (.当前() == ISK.addrspace) {
                    AddrSpace = .parseOptionalCommaAddrSpace(T);
                }
                else if (.当前() == ISK.MetadataVar) {
                    T = true;
                }
            }
        }
    }
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (T) {
        尾部数据 = .parseInstructionMetadata();
    }
    else {
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
    }
    分配指令_ n = 工厂.创建分配指令(Ty, IsInAlloca, IsSwiftError, Alignment, AddrSpace, Size, 尾部数据);
    return .完成节点!(分配指令_)(n, 开始);
}
IR节点_ parseOptionalCommaAddrSpace(ref bool T) {
    IR节点_ AddrSpace;
    while(.编译可选的(ISK.逗号)) {
        if (.当前() == ISK.MetadataVar) {
            T = true;
            return ··null!(IR节点_);
        }
        AddrSpace = .parseOptionalAddrSpace();
        if (AddrSpace is ··null!(IR节点_)) {
            // err
            return ··null!(IR节点_);
        }
    }
    return AddrSpace;
}
IR节点_ parseOptionalCommaAlign(ref bool T) {
    IR节点_ Alignment;
    while(.编译可选的(ISK.逗号)) {
        if (.当前() == ISK.MetadataVar) {
            T = true;
            return ··null!(IR节点_);
        }
        Alignment = .parseOptionalAlignment();
        if (Alignment is ··null!(IR节点_)) {
            // err
            return ··null!(IR节点_);
        }
    }
    return Alignment;
}
加载指令_ parseLoad() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.load);
    IR节点_ isAtomic;
    if (.当前() == ISK.atomic) {
        isAtomic = .编译IR令牌节点(.当前());
    }
    IR节点_ isVolatile;
    if (.当前() == ISK.volatile) {
        isVolatile = .编译IR令牌节点(.当前());
    }
    IR节点_ Ty = .parseType();
    .编译确定的(ISK.逗号);
    值表达式_ Val = .parseTypeAndValue();
    bool T = false;
    同步范围设置_ SSID;
    IR节点_ Ordering;
    if (isAtomic !is ··null!(IR节点_)) {
        SSID = .parseScope();
        Ordering = .parseOrdering();
    }
    IR节点_ Alignment = .parseOptionalCommaAlign(T);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (T) {
        尾部数据 = .parseInstructionMetadata();
    }
    else {
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
    }
    加载指令_ n = 工厂.创建加载指令(Ty, Val, isAtomic, isVolatile, Alignment, SSID, Ordering, 尾部数据);
    return .完成节点!(加载指令_)(n, 开始);
}
同步范围设置_ parseScope() {
    long 开始 = .获取节点开始();
    if (.编译可选的(ISK.syncscope)) {
        .编译确定的(ISK.左括号);
        IR文本字面量_ V = .parseStringConstant();
        .编译确定的(ISK.右括号);
        同步范围设置_ n = 工厂.创建同步范围设置(V);
        return .完成节点!(同步范围设置_)(n, 开始);
    }
    return ··null!(同步范围设置_);
}
IR节点_ parseOrdering() {
    switch (.当前()) {
        case ISK.unordered:
        case ISK.monotonic:
        case ISK.acquire:
        case ISK.release:
        case ISK.acq_rel:
        case ISK.seq_cst: {
            return .编译IR令牌节点(.当前());
        }
        default: break;
    }
    return ··null!(IR节点_);
}
储存指令_ parseStore() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.store);
    IR节点_ isAtomic;
    if (.当前() == ISK.atomic) {
        isAtomic = .编译IR令牌节点(.当前());
    }
    IR节点_ isVolatile;
    if (.当前() == ISK.volatile) {
        isVolatile = .编译IR令牌节点(.当前());
    }
    值表达式_ Val = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ Ptr = .parseTypeAndValue();
    bool T = false;
    同步范围设置_ SSID;
    IR节点_ Ordering;
    if (isAtomic !is ··null!(IR节点_)) {
        SSID = .parseScope();
        Ordering = .parseOrdering();
    }
    IR节点_ Alignment = .parseOptionalCommaAlign(T);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (T) {
        尾部数据 = .parseInstructionMetadata();
    }
    else {
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
    }
    储存指令_ n = 工厂.创建储存指令(Val, Ptr, isAtomic, isVolatile, Alignment, SSID, Ordering, 尾部数据);
    return .完成节点!(储存指令_)(n, 开始);
}
原子修改内存按条件指令_ parseCmpXchg() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.cmpxchg);
    IR节点_ isWeak;
    if (.当前() == ISK.weak) {
        isWeak = .编译IR令牌节点(.当前());
    }
    IR节点_ isVolatile;
    if (.当前() == ISK.volatile) {
        isVolatile = .编译IR令牌节点(.当前());
    }
    值表达式_ Ptr = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ Cmp = .parseTypeAndValue();
    .编译确定的(ISK.逗号);
    值表达式_ New = .parseTypeAndValue();
    同步范围设置_ SSID = .parseScope();
    IR节点_ SuccessOrdering = .parseOrdering();
    IR节点_ FailureOrdering = .parseOrdering();
    bool T = false;
    IR节点_ Alignment = .parseOptionalCommaAlign(T);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (T) {
        尾部数据 = .parseInstructionMetadata();
    }
    else {
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
    }
    原子修改内存按条件指令_ n = 工厂.创建原子修改内存按条件指令(Ptr, Cmp, New, SSID, SuccessOrdering, FailureOrdering, isWeak, isVolatile, Alignment, 尾部数据);
    return .完成节点!(原子修改内存按条件指令_)(n, 开始);
}
原子修改内存指令_ parseAtomicRMW() {
    IR节点_ delegate() parseOperation;
    long 开始;
    IR节点_ isVolatile;
    IR节点_ Operation;
    值表达式_ Ptr;
    值表达式_ Val;
    同步范围设置_ SSID;
    IR节点_ Ordering;
    bool T;
    IR节点_ Alignment;
    基础节点.节点数组_!(IR节点_) 尾部数据;
    原子修改内存指令_ n;
    IR节点_ parseOperation·func() {
        switch (.当前()) {
            case ISK.xchg:
            case ISK.add:
            case ISK.sub:
            case ISK.and:
            case ISK.nand:
            case ISK.or:
            case ISK.xor:
            case ISK.max:
            case ISK.min:
            case ISK.umax:
            case ISK.umin:
            case ISK.fadd:
            case ISK.fsub: {
                return .编译IR令牌节点(.当前());
            }
            default: break;
        }
        return .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.未知指令_0);
    }
    parseOperation = &parseOperation·func;
    开始 = .获取节点开始();
    .编译确定的(ISK.atomicrmw);
    if (.当前() == ISK.volatile) {
        isVolatile = .编译IR令牌节点(.当前());
    }
    Operation = parseOperation();
    Ptr = .parseTypeAndValue();
    .编译可选的(ISK.逗号);
    Val = .parseTypeAndValue();
    SSID = .parseScope();
    Ordering = .parseOrdering();
    T = false;
    Alignment = .parseOptionalCommaAlign(T);
    if (T) {
        尾部数据 = .parseInstructionMetadata();
    }
    else {
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
    }
    n = 工厂.创建原子修改内存指令(Operation, Ptr, Val, SSID, Ordering, isVolatile, Alignment, 尾部数据);
    return .完成节点!(原子修改内存指令_)(n, 开始);
}
栅格指令_ parseFence() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.fence);
    同步范围设置_ SSID = .parseScope();
    IR节点_ Ordering = .parseOrdering();
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (.编译可选的(ISK.逗号)) {
        尾部数据 = .parseInstructionMetadata();
    }
    栅格指令_ n = 工厂.创建栅格指令(SSID, Ordering, 尾部数据);
    return .完成节点!(栅格指令_)(n, 开始);
}
获取元素指针指令_ parseGetElementPtr() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.getelementptr);
    IR节点_ InBounds;
    if (.当前() == ISK.inbounds) {
        InBounds = .编译IR令牌节点(.当前());
    }
    IR节点_ Ty = .parseType();
    .编译可选的(ISK.逗号);
    值表达式_ Ptr = .parseTypeAndValue();
    bool T = false;
    值表达式_[] 数据组 = 创建数组!(值表达式_)();
    long 数组结束 = 0;
    while(.编译可选的(ISK.逗号)) {
        数组结束 = .获取节点开始();
        if (.当前() == ISK.MetadataVar) {
            T = true;
            break;
        }
        值表达式_ Val = .parseTypeAndValue();
        .追加!(值表达式_)(数据组, Val);
    }
    基础节点.节点数组_!(值表达式_) Indices;
    if (数据组.length > 0) {
        if (T) {
            Indices = .创建节点数组!(值表达式_)(数据组, 数据组[0].开始, 数组结束);
        }
        else {
            Indices = .创建节点数组!(值表达式_)(数据组, 数据组[0].开始);
        }
    }
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (T) {
        尾部数据 = .parseInstructionMetadata();
    }
    else {
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
    }
    获取元素指针指令_ n = 工厂.创建获取元素指针指令(Ty, Ptr, InBounds, Indices, 尾部数据);
    return .完成节点!(获取元素指针指令_)(n, 开始);
}
提取值指令_ parseExtractValue() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.extractvalue);
    值表达式_ Val = .parseTypeAndValue();
    bool T = false;
    基础节点.节点数组_!(IR节点_) Indices = .parseIndexList2(T);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (T) {
        尾部数据 = .parseInstructionMetadata();
    }
    else {
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
    }
    提取值指令_ n = 工厂.创建提取值指令(Val, Indices, 尾部数据);
    return .完成节点!(提取值指令_)(n, 开始);
}
基础节点.节点数组_!(IR节点_) parseIndexList2(ref bool T) {
    T = false;
    IR节点_[] Indices = 创建数组!(IR节点_)();
    long 数组开始 = -1;
    while(.编译可选的(ISK.逗号)) {
        if (数组开始 == -1) {
            数组开始 = .获取节点开始();
        }
        if (.当前() == ISK.MetadataVar) {
            T = true;
            break;
        }
        IR数字字面量_ V = .parseUInt32();
        .追加!(IR节点_)(Indices, V);
    }
    if (Indices.length > 0) {
        return .创建节点数组!(IR节点_)(Indices, 数组开始);
    }
    return ··null!(基础节点.节点数组_!(IR节点_));
}
插入值指令_ parseInsertValue() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.insertvalue);
    值表达式_ Val0 = .parseTypeAndValue();
    .编译可选的(ISK.逗号);
    值表达式_ Val1 = .parseTypeAndValue();
    bool T = false;
    基础节点.节点数组_!(IR节点_) Indices = .parseIndexList2(T);
    基础节点.节点数组_!(IR节点_) 尾部数据;
    if (T) {
        尾部数据 = .parseInstructionMetadata();
    }
    else {
        if (.编译可选的(ISK.逗号)) {
            尾部数据 = .parseInstructionMetadata();
        }
    }
    插入值指令_ n = 工厂.创建插入值指令(Val0, Val1, Indices, 尾部数据);
    return .完成节点!(插入值指令_)(n, 开始);
}
地址空间设置_ parseOptionalProgramAddrSpace() {
    return .parseOptionalAddrSpace();
}
基础节点.节点数组_!(IR节点_) parseParameterList() {
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] ArgList = 创建数组!(IR节点_)();
    while(.当前() != ISK.右括号) {
        if (ArgList.length != 0) {
            .编译确定的(ISK.逗号);
        }
        long 参数开始 = .获取节点开始();
        if (.当前() == ISK.三点号) {
            IR节点_ n = .编译IR令牌节点(.当前());
            实参表达式_ an = 工厂.创建实参表达式(n);
            .追加!(IR节点_)(ArgList, an);
            break;
        }
        IR节点_ ArgTy = .parseType();
        IR节点_ V;
        基础节点.节点数组_!(IR节点_) ArgAttrs;
        if (ArgTy.目标种类 == ISK.metadata) {
            V = .parseMetadataAsValue();
        }
        else {
            ArgAttrs = .parseOptionalParamAttrs();
            V = .parseValue();
        }
        值表达式_ a = 工厂.创建值表达式(ArgTy, V);
        a.开始 = 参数开始;
        a.结束 = V.结束;
        实参表达式_ an = 工厂.创建实参表达式(a, ArgAttrs);
        if ((ArgAttrs !is null) && (ArgAttrs.原型 !is ··null!(IR节点_[]))) {
            an.开始 = a.开始;
            an.结束 = ArgAttrs.结束;
        }
        else {
            an.开始 = a.开始;
            an.结束 = a.结束;
        }
        .追加!(IR节点_)(ArgList, an);
    }
    .编译确定的(ISK.右括号);
    return .创建节点数组!(IR节点_)(ArgList, 数组开始);
}
操作数标签组_ parseOptionalOperandBundles() {
    if (.当前() != ISK.左方括号) {
        return ··null!(操作数标签组_);
    }
    long 开始 = .获取节点开始();
    .编译确定的(ISK.左方括号);
    long 数组开始 = .获取节点开始();
    操作数标签_[] 数据组 = 创建数组!(操作数标签_)();
    while(.当前() != ISK.右方括号) {
        if (数据组.length > 0) {
            .编译确定的(ISK.逗号);
        }
        IR文本字面量_ tag = .parseStringConstant();
        IR标识符_ Tag = 工厂.创建IR标识符(标识符分类_.文本内容标识符_, tag);
        .编译确定的(ISK.左括号);
        long 数组开始2 = .获取节点开始();
        值表达式_[] 数据组2 = 创建数组!(值表达式_)();
        while(.当前() != ISK.右括号) {
            if (数据组2.length > 0) {
                .编译确定的(ISK.逗号);
            }
            IR节点_ Ty = .parseType();
            IR节点_ Val = .parseValue();
            值表达式_ 值表达式 = 工厂.创建值表达式(Ty, Val);
            值表达式 = .完成节点!(值表达式_)(值表达式, Ty.开始);
            .追加!(值表达式_)(数据组2, 值表达式);
        }
        基础节点.节点数组_!(值表达式_) 操作数组 = .创建节点数组!(值表达式_)(数据组2, 数组开始2);
        .编译确定的(ISK.右括号);
        操作数标签_ nn = 工厂.创建操作数标签(Tag, 操作数组);
        nn = .完成节点!(操作数标签_)(nn, Tag.开始);
        .追加!(操作数标签_)(数据组, nn);
    }
    基础节点.节点数组_!(操作数标签_) 标签组 = .创建节点数组!(操作数标签_)(数据组, 数组开始);
    .编译确定的(ISK.右方括号);
    操作数标签组_ ns = 工厂.创建操作数标签组(标签组);
    return .完成节点!(操作数标签组_)(ns, 开始);
}
值表达式_ parseTypeAndValue() {
    long 开始 = .获取节点开始();
    IR节点_ 类型 = .parseType();
    IR节点_ 值 = .parseValue();
    值表达式_ 值表达式 = 工厂.创建值表达式(类型, 值);
    return .完成节点!(值表达式_)(值表达式, 开始);
}
值表达式_ parseTypeAndBasicBlock() {
    return .parseTypeAndValue();
}
基础节点.节点数组_!(IR节点_) parseInstructionMetadata() {
    bool 第一层 = false;
    long 节点数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    while(!第一层 || .编译可选的(ISK.逗号)) {
        第一层 = true;
        assert(.当前() == ISK.MetadataVar, "不是MetadataVar"c);
        IR节点_ MD = .parseMetadataAttachment();
        .追加!(IR节点_)(数据组, MD);
    }
    return .创建节点数组!(IR节点_)(数据组, 节点数组开始);
}
IR节点_ parseValue() {
    return .parseValID();
}
/// MDNode:
///  ::= !{ ... }
///  ::= !7
///  ::= !DILocation(...)
IR节点_ parseMDNode() {
    if (.当前() == ISK.MetadataVar) {
        return .parseSpecializedMDNode();
    }
    long 开始 = .获取节点开始();
    .编译确定的(ISK.叹号);
    return .parseMDNodeTail(开始);
}
IR节点_ parseMDNodeTail(long 开始 = ··null!(long)) {
    // !{ ... }
    if (.当前() == ISK.左大括号) {
        return .parseMDTuple(开始);
    }
    // !42
    return .parseMDNodeID(开始);
}
MDNodeVector_ parseMDTuple(long 开始 = ··null!(long)) {
    return .parseMDNodeVector(开始);
}
/// parseMDNodeVector
///   ::= { Element (',' Element)* }
/// Element
///   ::= 'null' | TypeAndValue
MDNodeVector_ parseMDNodeVector(long 开始 = ··null!(long)) {
    开始 = ((开始) !is ··null!(long)) ? 开始 : .获取节点开始();
    .编译确定的(ISK.左大括号);
    long 数组开始 = .获取节点开始();
    if (.编译可选的(ISK.右大括号)) {
        MDNodeVector_ n = 工厂.创建MDNodeVector();
        return .完成节点!(MDNodeVector_)(n, 开始);
    }
    bool 第一层 = false;
    IR节点_[] 元素组 = 创建数组!(IR节点_)();
    while(!第一层 || .编译可选的(ISK.逗号)) {
        第一层 = true;
        if (.当前() == ISK.null_) {
            IR节点_ null_ = .编译IR令牌节点(.当前());
            .追加!(IR节点_)(元素组, null_);
            continue;
        }
        .追加!(IR节点_)(元素组, .parseMetadata());
    }
    基础节点.节点数组_!(IR节点_) 元素节点数组 = .创建节点数组!(IR节点_)(元素组, 数组开始);
    .编译确定的(ISK.右大括号);
    MDNodeVector_ n2 = 工厂.创建MDNodeVector(元素节点数组);
    return .完成节点!(MDNodeVector_)(n2, 开始);
}
/// parseMetadataAsValue
///  ::= metadata i32 %local
///  ::= metadata i32 @global
///  ::= metadata i32 7
///  ::= metadata !0
///  ::= metadata !{...}
///  ::= metadata !"string"
IR节点_ parseMetadataAsValue() {
    // Note: the type 'metadata' has already been parsed.
    return .parseMetadata();
}
/// parseValueAsMetadata
///  ::= i32 %local
///  ::= i32 @global
///  ::= i32 7
全局表达式_ parseValueAsMetadata() {
    long 开始 = .获取节点开始();
    IR节点_ Ty = .parseType();
    IR节点_ Val = .parseValue();
    全局表达式_ n = 工厂.创建全局表达式(Ty, Val);
    n.开始 = Ty.开始;
    n.结束 = Val.结束;
    return n;
}
/// parseMetadata
///  ::= i32 %local
///  ::= i32 @global
///  ::= i32 7
///  ::= !42
///  ::= !{...}
///  ::= !"string"
///  ::= !DILocation(...)
IR节点_ parseMetadata() {
    if (.当前() == ISK.MetadataVar) {
        // DIArgLists are a special case, as they are a list of ValueAsMetadata and
        // so parsing this requires a Function State.
        if (.getStrVal().内容 == "DIArgList"d) {
            return .parseDIArgList();
        }
        return .parseSpecializedMDNode();
    }
    // ValueAsMetadata:
    // <type> <value>
    if (.当前() != ISK.叹号) {
        return .parseValueAsMetadata();
    }
    // '!'.
    assert(.当前() == ISK.叹号, "Expected '!' here"c);
    .下个();
    // MDString:
    //   ::= '!' STRINGCONSTANT
    if (.当前() == ISK.StringConstant) {
        return .parseMDString();
    }
    return .parseMDNodeTail();
}
// MDNode:
//   ::= '!' MDNodeNumber
IR节点_ parseMDNodeID(long 开始 = ··null!(long)) {
    IR数字字面量_ n = .parseUInt32();
    n.标志 |= (cast(整数_)(节点标志_.MD_));
    if (开始 !is ··null!(long)) {
        n.开始 = 开始;
    }
    return n;
}
/// parseNamedMetadata:
///   !foo = !{ !1, !2 }
元数据声明_ parseNamedMetadata() {
    long 开始 = .获取节点开始();
    IR文本字面量_ name = .getStrVal();
    IR标识符_ Name = 工厂.创建IR标识符(.获取标识符分类(name, 标识符分类_.元数据标识符_), name);
    .编译确定的(ISK.等号);
    .编译确定的(ISK.叹号);
    .编译确定的(ISK.左大括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] NMD = [];
    if (.当前() != ISK.右大括号) {
        bool 第一层 = false;
        while(!第一层 || .编译可选的(ISK.逗号)) {
            第一层 = true;
            IR节点_ N;
            if (.当前() == ISK.MetadataVar && .getStrVal().内容 == "DIExpression"d) {
                N = .parseDIExpression();
            }
            else {
                .编译确定的(ISK.叹号);
                N = .parseMDNodeID();
            }
            .追加!(IR节点_)(NMD, N);
        }
    }
    基础节点.节点数组_!(IR节点_) 成员组 = .创建节点数组!(IR节点_)(NMD, 开始);
    .编译确定的(ISK.右大括号);
    元数据声明_ n = 工厂.创建元数据声明(Name, 成员组);
    return .完成节点!(元数据声明_)(n, 开始);
}
/// parseStandaloneMetadata:
///   !42 = !{...}
独立元数据_ parseStandaloneMetadata() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.叹号);
    IR数字字面量_ MetadataID = .parseUInt32();
    IR标识符_ Name = 工厂.创建IR标识符(标识符分类_.元数据标识符_ | 标识符分类_.ID标识符_, MetadataID);
    .编译确定的(ISK.等号);
    IR节点_ IsDistinct;
    if (.当前() == ISK.distinct) {
        IsDistinct = .编译IR令牌节点(.当前());
    }
    IR节点_ init;
    if (.当前() == ISK.MetadataVar) {
        init = .parseSpecializedMDNode();
    }
    else {
        .编译确定的(ISK.叹号);
        init = .parseMDTuple();
    }
    独立元数据_ n = 工厂.创建独立元数据(Name, init, IsDistinct);
    return .完成节点!(独立元数据_)(n, 开始);
}
DIExpression_ parseDIExpression() {
    IR文本字面量_ Val = .getStrVal();
    long 开始 = Val.开始;
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    基础节点.节点数组_!(IR节点_) 元素节点数组;
    if (.当前() != ISK.右括号) {
        bool 第一层 = false;
        IR节点_[] 元素组 = 创建数组!(IR节点_)();
        while(!第一层 || .编译可选的(ISK.逗号)) {
            第一层 = true;
            if (.当前() == ISK.DwarfOp || .当前() == ISK.DwarfAttEncoding) {
                IR文本字面量_ 值 = .getStrVal();
                .追加!(IR节点_)(元素组, 值);
            }
            else {
                IR数字字面量_ 值 = .getAPSIntVal();
                .追加!(IR节点_)(元素组, 值);
            }
        }
        元素节点数组 = .创建节点数组!(IR节点_)(元素组, 数组开始);
    }
    .编译确定的(ISK.右括号);
    DIExpression_ n = 工厂.创建DIExpression(元素节点数组);
    return .完成节点!(DIExpression_)(n, 开始);
}
DIArgList_ parseDIArgList() {
    IR文本字面量_ Val = .getStrVal();
    long 开始 = Val.开始;
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    基础节点.节点数组_!(IR节点_) 元素节点数组;
    if (.当前() != ISK.右括号) {
        bool 第一层 = false;
        IR节点_[] 元素组 = 创建数组!(IR节点_)();
        while(!第一层 || .编译可选的(ISK.逗号)) {
            第一层 = true;
            全局表达式_ 值 = .parseValueAsMetadata();
            .追加!(IR节点_)(元素组, 值);
        }
        元素节点数组 = .创建节点数组!(IR节点_)(元素组, 数组开始);
    }
    .编译确定的(ISK.右括号);
    DIArgList_ n = 工厂.创建DIArgList(元素节点数组);
    return .完成节点!(DIArgList_)(n, 开始);
}
基础节点.节点数组_!(IR节点_) parseOptionalFunctionMetadata() {
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据 = 创建数组!(IR节点_)();
    while(.当前() == ISK.MetadataVar) {
        IR节点_ MD = .parseGlobalObjectMetadataAttachment();
        .追加!(IR节点_)(数据, MD);
    }
    if (数据.length > 0) {
        return .创建节点数组!(IR节点_)(数据, 数组开始);
    }
    return ··null!(基础节点.节点数组_!(IR节点_));
}
IR节点_ parseGlobalObjectMetadataAttachment() {
    return .parseMetadataAttachment();
}
IR节点_ parseMetadataAttachment() {
    long 开始 = .获取节点开始();
    assert(.当前() == ISK.MetadataVar, "不是MetadataVar"c);
    IR文本字面量_ name = .getStrVal();
    IR节点_ MD = .parseMDNode();
    元数据字段_ n = 工厂.创建元数据字段(name, MD);
    return .完成节点!(元数据字段_)(n, 开始);
}
IR节点_ parseSpecializedMDNode() {
    IR节点_ delegate() 内部编译;
    IR节点_ 内部编译·func() {
        dstring id;
        id = .getStrVal().内容;
        switch (id) {
            case "DILocation"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DILocation), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DILocation));
            }
            case "GenericDINode"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译GenericDINode), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成GenericDINode));
            }
            case "DISubrange"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DISubrange), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成专用节点));
            }
            case "DIGenericSubrange"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIGenericSubrange), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成专用节点));
            }
            case "DIEnumerator"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIEnumerator), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DIEnumerator));
            }
            case "DIBasicType"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIBasicType), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成专用节点));
            }
            case "DIStringType"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIStringType), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成专用节点));
            }
            case "DIDerivedType"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIDerivedType), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DIDerivedType));
            }
            case "DICompositeType"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DICompositeType), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DICompositeType));
            }
            case "DISubroutineType"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DISubroutineType), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DISubroutineType));
            }
            case "DIFile"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIFileType), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DIFileType));
            }
            case "DICompileUnit"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DICompileUnit), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DICompileUnit));
            }
            case "DISubprogram"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DISubprogram), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成专用节点));
            }
            case "DILexicalBlock"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DILexicalBlock), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DILexicalBlock));
            }
            case "DILexicalBlockFile"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DILexicalBlockFile), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DILexicalBlockFile));
            }
            case "DICommonBlock"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DICommonBlock), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DICommonBlock));
            }
            case "DINamespace"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DINamespace), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DINamespace));
            }
            case "DIMacro"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIMacro), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DIMacro));
            }
            case "DIMacroFile"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIMacroFile), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DIMacroFile));
            }
            case "DIModule"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIModule), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DIModule));
            }
            case "DITemplateTypeParameter"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DITemplateTypeParameter), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DITemplateTypeParameter));
            }
            case "DITemplateValueParameter"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DITemplateValueParameter), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DITemplateValueParameter));
            }
            case "DIGlobalVariable"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIGlobalVariable), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DIGlobalVariable));
            }
            case "DILocalVariable"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DILocalVariable), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DILocalVariable));
            }
            case "DILabel"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DILabel), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DILabel));
            }
            case "DIGlobalVariableExpression"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIGlobalVariableExpression), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DIGlobalVariableExpression));
            }
            case "DIObjCProperty"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIObjCProperty), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成专用节点));
            }
            case "DIImportedEntity"d: {
                return _MDP.parseMDFieldsImpl(cast(void delegate())(&_MDP.编译DIImportedEntity), cast(IR节点_ delegate(IR标识符_, 基础节点.节点数组_!(IR节点_)))(&_MDP.完成DIImportedEntity));
            }
            case "MDString"d: {
                return .parseMDString();
            }
            case "DIExpression"d: {
                return .parseDIExpression();
            }
            case "DIArgList"d: {
                return .parseDIArgList();
            }
            default: break;
        }
        return .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.expected_metadata_type);
    }
    内部编译 = &内部编译·func;
    return 内部编译();
}
bool isReturnAttrs(ISK isk) {
    switch (isk) {
        case ISK.StringConstant:
        case ISK.dereferenceable:
        case ISK.dereferenceable_or_null:
        case ISK.align_:
        case ISK.inreg:
        case ISK.noalias:
        case ISK.noundef:
        case ISK.nonnull:
        case ISK.signext:
        case ISK.zeroext: {
            return true;
        }
        default: break;
    }
    return false;
}
基础节点.节点数组_!(IR节点_) parseOptionalReturnAttrs() {
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    while(.isReturnAttrs(.当前())) {
        long 开始 = .获取节点开始();
        switch (.当前()) {
            case ISK.StringConstant: {
                .追加!(IR节点_)(数据组, .parseStringAttribute());
                continue;
            }
            case ISK.dereferenceable: {
                .追加!(IR节点_)(数据组, .parseOptionalDerefAttrBytes(ISK.dereferenceable));
                continue;
            }
            case ISK.dereferenceable_or_null: {
                .追加!(IR节点_)(数据组, .parseOptionalDerefAttrBytes(ISK.dereferenceable_or_null));
                continue;
            }
            case ISK.align_: {
                .追加!(IR节点_)(cast(IR节点_[])(数据组), .parseOptionalAlignment());
                continue;
            }
            case ISK.inreg:
            case ISK.noalias:
            case ISK.noundef:
            case ISK.nonnull:
            case ISK.signext:
            case ISK.zeroext: {
                IR节点_ n = .编译IR令牌节点(.当前());
                .追加!(IR节点_)(数据组, n);
                break;
            }
            default: {
                break;
            }
        }
    }
    if (数据组.length > 0) {
        return .创建节点数组!(IR节点_)(数据组, 数组开始);
    }
    return ··null!(基础节点.节点数组_!(IR节点_));
}
自定义特性设置_ parseStringAttribute() {
    long 开始 = .获取节点开始();
    IR文本字面量_ Attr = .parseStringConstant();
    IR节点_ Val;
    if (.编译可选的(ISK.等号)) {
        Val = .parseStringConstant();
    }
    自定义特性设置_ n = 工厂.创建自定义特性设置(Attr, Val);
    return .完成节点!(自定义特性设置_)(n, 开始);
}
IR节点_ parseOptionalDerefAttrBytes(ISK kind) {
    long 开始 = .获取节点开始();
    .编译确定的(kind);
    .编译确定的(ISK.左括号);
    IR数字字面量_ 值 = .parseUInt64();
    .编译确定的(ISK.右括号);
    if (kind == ISK.dereferenceable) {
        ··IR节点_.不可引用的设置_ n = 工厂.创建不可引用的设置(值);
        return .完成节点!(··IR节点_.不可引用的设置_)(n, 开始);
    }
    assert(kind == ISK.dereferenceable_or_null, "不是ISK.dereferenceable"c);
    ··IR节点_.不可引用的或空设置_ n = 工厂.创建不可引用的或空设置(值);
    return .完成节点!(··IR节点_.不可引用的或空设置_)(n, 开始);
}
对齐设置_ parseOptionalAlignment(bool AllowParens = false) {
    if (.当前() != ISK.align_) {
        return ··null!(对齐设置_);
    }
    long 开始 = .获取节点开始();
    .编译确定的(ISK.align_);
    bool 有括号 = false;
    if (AllowParens) {
        if (.编译可选的(ISK.左括号)) {
            有括号 = true;
        }
    }
    IR数字字面量_ Val = .parseUInt32();
    if (有括号) {
        .编译确定的(ISK.右括号);
    }
    对齐设置_ n = 工厂.创建对齐设置(Val);
    n.有括号 = 有括号;
    return .完成节点!(对齐设置_)(n, 开始);
}
LinkKage_ parseOptionalLinkage() {
    LinkKage_ link = .LinkKage_();
    link.LinkageAux = .parseOptionalLinkageAux();
    link.DSOLocal = .parseOptionalDSOLocal();
    link.Visibility = .parseOptionalVisibility();
    link.DLLStorageClass = .parseOptionalDLLStorageClass(link.DSOLocal);
    return link;
}
IR节点_ parseOptionalDLLStorageClass(IR节点_ DSOLocal = ··null!(IR节点_)) {
    long 开始 = .获取节点开始();
    switch (.当前()) {
        case ISK.dllimport: {
            IR节点_ n = .编译IR令牌节点(.当前());
            if (DSOLocal !is ··null!(IR节点_)) {
                .编译错误在(开始, .获取节点开始(), 诊断集_.dso_location_and_DLL_StorageClass_mismatch, ""d);
            }
            return n;
        }
        case ISK.dllexport: {
            return .编译IR令牌节点(.当前());
        }
        default: break;
    }
    return ··null!(IR节点_);
}
IR节点_ parseOptionalVisibility() {
    switch (.当前()) {
        case ISK.default_:
        case ISK.hidden:
        case ISK.protected_: {
            return .编译IR令牌节点(.当前());
        }
        default: break;
    }
    return ··null!(IR节点_);
}
IR节点_ parseOptionalDSOLocal() {
    switch (.当前()) {
        case ISK.dso_local:
        case ISK.dso_preemptable: {
            return .编译IR令牌节点(.当前());
        }
        default: break;
    }
    return ··null!(IR节点_);
}
IR节点_ parseOptionalLinkageAux() {
    switch (.当前()) {
        case ISK.private_:
        case ISK.internal:
        case ISK.weak:
        case ISK.weak_odr:
        case ISK.linkonce:
        case ISK.linkonce_odr:
        case ISK.available_externally:
        case ISK.appending:
        case ISK.common:
        case ISK.extern_weak:
        case ISK.external: {
            return .编译IR令牌节点(.当前());
        }
        default: break;
    }
    return ··null!(IR节点_);
}
IR节点_ parseTargetDefinition() {
    long 开始 = .获取节点开始();
    .下个();
    switch (.当前()) {
        case ISK.triple: {
            .下个();
            .编译确定的(ISK.等号);
            IR文本字面量_ str = .parseStringConstant();
            ··IR节点_.平台设置_ 结果 = 工厂.创建平台设置(str);
            return .完成节点!(··IR节点_.平台设置_)(结果, 开始);
        }
        case ISK.datalayout: {
            .下个();
            .编译确定的(ISK.等号);
            IR文本字面量_ str = .parseStringConstant();
            ··IR节点_.数据布局设置_ 结果 = 工厂.创建数据布局设置(str);
            return .完成节点!(··IR节点_.数据布局设置_)(结果, 开始);
        }
        default: {
            return .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.unknown_target_property);
        }
    }
}
IR节点_ parseOptionalCallingConv() {
    long 开始 = .获取节点开始();
    switch (.当前()) {
        case ISK.ccc:
        case ISK.fastcc:
        case ISK.coldcc:
        case ISK.cfguard_checkcc:
        case ISK.x86_stdcallcc:
        case ISK.x86_fastcallcc:
        case ISK.x86_regcallcc:
        case ISK.x86_thiscallcc:
        case ISK.x86_vectorcallcc:
        case ISK.arm_apcscc:
        case ISK.arm_aapcscc:
        case ISK.arm_aapcs_vfpcc:
        case ISK.aarch64_vector_pcs:
        case ISK.aarch64_sve_vector_pcs:
        case ISK.msp430_intrcc:
        case ISK.avr_intrcc:
        case ISK.avr_signalcc:
        case ISK.ptx_kernel:
        case ISK.ptx_device:
        case ISK.spir_kernel:
        case ISK.spir_func:
        case ISK.intel_ocl_bicc:
        case ISK.x86_64_sysvcc:
        case ISK.win64cc:
        case ISK.webkit_jscc:
        case ISK.anyregcc:
        case ISK.preserve_mostcc:
        case ISK.preserve_allcc:
        case ISK.ghccc:
        case ISK.swiftcc:
        case ISK.swifttailcc:
        case ISK.x86_intrcc:
        case ISK.hhvmcc:
        case ISK.hhvm_ccc:
        case ISK.cxx_fast_tlscc:
        case ISK.amdgpu_vs:
        case ISK.amdgpu_gfx:
        case ISK.amdgpu_ls:
        case ISK.amdgpu_hs:
        case ISK.amdgpu_es:
        case ISK.amdgpu_gs:
        case ISK.amdgpu_ps:
        case ISK.amdgpu_cs:
        case ISK.amdgpu_kernel:
        case ISK.tailcc: {
            return .编译IR令牌节点(.当前());
        }
        case ISK.cc: {
            bool 有错误 = false;
            if (.APSIntVal is ··null!(dstring)) {
                .下个();
                if (.当前() != ISK.APSInt) {
                    有错误 = true;
                }
            }
            IR数字字面量_ Val = .parseUInt32();
            ··IR节点_.CC调用约定设置_ n = 工厂.创建CC调用约定设置(Val);
            if (有错误) {
                .编译错误在(开始, .获取节点开始(), 诊断集_.expected_integer, ""d);
            }
            return .完成节点!(··IR节点_.CC调用约定设置_)(n, 开始);
        }
        default: break;
    }
    return ··null!(IR节点_);
}
IR节点_ parseType(bool AllowVoid = false) {
    long 开始 = .获取节点开始();
    IR节点_ type;
    ISK kind = .当前();
    switch (kind) {
        case ISK.Type: {
            IR数字字面量_ 内容 = .getTyVal();
            type = 工厂.创建整数类型(内容);
            .完成节点!(IR节点_)(type, 开始);
            break;
        }
        case ISK.void_:
        case ISK.ptr:
        case ISK.half:
        case ISK.bfloat:
        case ISK.float_:
        case ISK.double_:
        case ISK.x86_fp80:
        case ISK.fp128:
        case ISK.ppc_fp128:
        case ISK.label:
        case ISK.metadata:
        case ISK.x86_mmx:
        case ISK.x86_amx:
        case ISK.token: {
            type = .编译IR令牌节点(.当前());
            break;
        }
        case ISK.左大括号: {
            type = .parseAnonStructType(开始, false);
            break;
        }
        case ISK.左方括号: {
            .下个();
            type = .parseArrayVectorType(开始, false);
            break;
        }
        case ISK.左尖括号: {
            .下个();
            if (.当前() == ISK.左大括号) {
                type = .parseAnonStructType(开始, true);
            }
            else {
                type = .parseArrayVectorType(开始, true);
            }
            break;
        }
        case ISK.LocalVar: {
            IR文本字面量_ na = .getStrVal();
            IR标识符_ name = 工厂.创建IR标识符(.获取标识符分类(na, 标识符分类_.类型标识符_), na);
            ··IR节点_.类型引用_ tn = 工厂.创建类型引用(name);
            type = .完成节点!(··IR节点_.类型引用_)(tn, type.开始);
            break;
        }
        case ISK.LocalVarID: {
            IR数字字面量_ na = .getUIntVal();
            IR标识符_ name = 工厂.创建IR标识符(标识符分类_.类型标识符_ | 标识符分类_.ID标识符_, na);
            ··IR节点_.类型引用_ tn = 工厂.创建类型引用(name);
            type = .完成节点!(··IR节点_.类型引用_)(tn, type.开始);
            break;
        }
        default: break;
    }
    if (kind == ISK.ptr) {
        地址空间设置_ AddrSpace = .parseOptionalAddrSpace();
        if (AddrSpace !is ··null!(地址空间设置_)) {
            long k = type.开始;
            type = 工厂.创建不透明指针类型(AddrSpace);
            type = .完成节点!(IR节点_)(type, k);
        }
        if (.当前() != ISK.左括号) {
            return type;
        }
    }
    while(true) {
        if (.当前() == ISK.星号) {
            long k = type.开始;
            .编译确定的(ISK.星号);
            指针类型_ ptr = 工厂.创建指针类型(type);
            type = .完成节点!(指针类型_)(ptr, k);
        }
        else if (.当前() == ISK.addrspace) {
            long k = type.开始;
            地址空间设置_ AddrSpace = .parseOptionalAddrSpace();
            .编译确定的(ISK.星号);
            type = 工厂.创建指针类型(type, AddrSpace);
            type = .完成节点!(IR节点_)(type, k);
        }
        else if (.当前() == ISK.左括号) {
            type = .parseFunctionType(type);
        }
        else {
            if (!AllowVoid && type.目标种类 == ISK.void_) {
                .编译错误在(type.开始, type.结束, 诊断集_.void_type_only_allowed_for_function_results, ""d);
            }
            break;
        }
    }
    return type;
}
IR节点_ parseFunctionType(IR节点_ retType) {
    bool delegate(IR节点_) isValidReturnType;
    long 开始;
    bool IsVarArg;
    基础节点.节点数组_!(IR节点_) args;
    函数类型_ n2;
    bool isValidReturnType·func(IR节点_ RetTy) {
        return RetTy.目标种类 != ISK.函数类型 && RetTy.目标种类 != ISK.label && RetTy.目标种类 != ISK.metadata;
    }
    isValidReturnType = &isValidReturnType·func;
    开始 = retType.开始;
    if (!isValidReturnType(retType)) {
        .编译错误在(retType.开始, retType.结束, 诊断集_.invalid_function_return_type, ""d);
    }
    IsVarArg = false;
    args = .parseArgumentList(IsVarArg);
    foreach (IR节点_ e; args) {
        if (e.目标种类 == ISK.三点号) {
            continue;
        }
        IR标识符_ name = (cast(形参声明_)(e)).name;
        IR节点_ t = (cast(形参声明_)(e)).类型;
        if (t.目标种类 == ISK.void_) {
            .编译错误在(t.开始, t.结束, 诊断集_.argument_can_not_have_void_type, ""d);
        }
        if (name !is ··null!(IR标识符_)) {
            .编译错误在(name.开始, name.结束, 诊断集_.argument_name_invalid_in_function_type, ""d);
        }
        if (((cast(形参声明_)(e)).形参特性 !is null) && ((cast(形参声明_)(e)).形参特性.原型 !is ··null!(IR节点_[])) && (cast(形参声明_)(e)).形参特性.length != 0) {
            .编译错误在((cast(形参声明_)(e)).形参特性.开始, (cast(形参声明_)(e)).形参特性.结束, 诊断集_.argument_attributes_invalid_in_function_type, ""d);
        }
    }
    n2 = 工厂.创建函数类型(retType, args, IsVarArg);
    return .完成节点!(函数类型_)(n2, 开始);
}
基础节点.节点数组_!(IR节点_) parseArgumentList(ref bool IsVarArg) {
    uint CurValID = 0;
    IsVarArg = false;
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    if (.当前() == ISK.右括号) {
    }
    else if (.当前() == ISK.三点号) {
        IR节点_ n0 = .编译IR令牌节点(.当前());
        .追加!(IR节点_)(数据组, n0);
        IsVarArg = true;
    }
    else {
        long k = .获取节点开始();
        IR节点_ ArgTy = .parseType();
        基础节点.节点数组_!(IR节点_) Attrs = .parseOptionalParamAttrs();
        IR标识符_ Name;
        if (.当前() == ISK.LocalVar) {
            IR文本字面量_ name = .getStrVal();
            Name = 工厂.创建IR标识符(.获取标识符分类(name, 标识符分类_.局部标识符_), name);
        }
        else if (.当前() == ISK.LocalVarID) {
            IR数字字面量_ name = .getUIntVal();
            Name = 工厂.创建IR标识符(标识符分类_.局部标识符_ | 标识符分类_.ID标识符_, name);
        }
        形参声明_ n = 工厂.创建形参声明(Name, ArgTy, Attrs);
        n = .完成节点!(形参声明_)(n, k);
        .追加!(IR节点_)(数据组, n);
        while(.编译可选的(ISK.逗号)) {
            if (.当前() == ISK.三点号) {
                IR节点_ n2 = .编译IR令牌节点(.当前());
                .追加!(IR节点_)(数据组, n2);
                break;
            }
            ArgTy = .parseType();
            Attrs = .parseOptionalParamAttrs();
            if (.当前() == ISK.LocalVar) {
                IR文本字面量_ name = .getStrVal();
                Name = 工厂.创建IR标识符(.获取标识符分类(name, 标识符分类_.局部标识符_), name);
            }
            else if (.当前() == ISK.LocalVarID) {
                IR数字字面量_ name = .getUIntVal();
                Name = 工厂.创建IR标识符(标识符分类_.局部标识符_ | 标识符分类_.ID标识符_, name);
            }
            n = 工厂.创建形参声明(Name, ArgTy, Attrs);
            n = .完成节点!(形参声明_)(n, k);
            .追加!(IR节点_)(数据组, n);
        }
    }
    基础节点.节点数组_!(IR节点_) 节点数组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
    .编译确定的(ISK.右括号);
    return 节点数组;
}
bool isFnAttributeValuePairs(ISK isk) {
    switch (isk) {
        case ISK.AttrGrpID:
        case ISK.StringConstant:
        case ISK.align_:
        case ISK.alignstack:
        case ISK.allocsize:
        case ISK.vscale_range:
        case ISK.alwaysinline:
        case ISK.argmemonly:
        case ISK.builtin:
        case ISK.cold:
        case ISK.hot:
        case ISK.convergent:
        case ISK.inaccessiblememonly:
        case ISK.inaccessiblemem_or_argmemonly:
        case ISK.inlinehint:
        case ISK.jumptable:
        case ISK.minsize:
        case ISK.mustprogress:
        case ISK.naked:
        case ISK.nobuiltin:
        case ISK.nocallback:
        case ISK.noduplicate:
        case ISK.nofree:
        case ISK.noimplicitfloat:
        case ISK.noinline:
        case ISK.nonlazybind:
        case ISK.nomerge:
        case ISK.noredzone:
        case ISK.noreturn:
        case ISK.nosync:
        case ISK.nocf_check:
        case ISK.noprofile:
        case ISK.norecurse:
        case ISK.nounwind:
        case ISK.nosanitize_coverage:
        case ISK.null_pointer_is_valid:
        case ISK.optforfuzzing:
        case ISK.optnone:
        case ISK.optsize:
        case ISK.readnone:
        case ISK.readonly:
        case ISK.returns_twice:
        case ISK.speculatable:
        case ISK.ssp:
        case ISK.sspreq:
        case ISK.sspstrong:
        case ISK.safestack:
        case ISK.shadowcallstack:
        case ISK.sanitize_address:
        case ISK.sanitize_hwaddress:
        case ISK.sanitize_memtag:
        case ISK.sanitize_thread:
        case ISK.sanitize_memory:
        case ISK.speculative_load_hardening:
        case ISK.strictfp:
        case ISK.uwtable:
        case ISK.willreturn:
        case ISK.writeonly:
        case ISK.preallocated: {
            return true;
        }
        default: break;
    }
    return false;
}
基础节点.节点数组_!(IR节点_) parseFnAttributeValuePairs(bool InAttrGrp = false) {
    if (InAttrGrp) {
        .编译确定的(ISK.左大括号);
    }
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    循环体: while(.isFnAttributeValuePairs(.当前())) {
        ISK Token = .当前();
        long 开始 = .获取节点开始();
        switch (Token) {
            case ISK.StringConstant: {
                .追加!(IR节点_)(数据组, .parseStringAttribute());
                continue;
            }
            case ISK.AttrGrpID: {
                IR数字字面量_ Val = .getUIntVal();
                IR标识符_ name = 工厂.创建IR标识符(标识符分类_.特性标识符_ | 标识符分类_.ID标识符_, Val);
                if (InAttrGrp) {
                    .编译错误在(Val.开始, Val.结束, 诊断集_.cannot_have_an_attribute_group_reference_in_an_attribute_group, ""d);
                }
                .追加!(IR节点_)(数据组, name);
                break;
            }
            case ISK.align_: {
                if (InAttrGrp) {
                    .下个();
                    .编译确定的(ISK.等号);
                    IR数字字面量_ Val = .parseUInt32();
                    对齐设置_ n = 工厂.创建对齐设置(Val);
                    n.等号 = true;
                    n = .完成节点!(对齐设置_)(n, 开始);
                    .追加!(IR节点_)(数据组, n);
                    break;
                }
                else {
                    .追加!(IR节点_)(数据组, .parseOptionalAlignment());
                    break;
                }
            }
            case ISK.alignstack: {
                if (InAttrGrp) {
                    .下个();
                    .编译确定的(ISK.等号);
                    IR数字字面量_ Val = .parseUInt32();
                    对齐堆栈设置_ n = 工厂.创建对齐堆栈设置(Val);
                    n.等号 = true;
                    n = .完成节点!(对齐堆栈设置_)(n, 开始);
                    .追加!(IR节点_)(数据组, n);
                    break;
                }
                else {
                    .追加!(IR节点_)(数据组, .parseOptionalStackAlignment());
                    break;
                }
            }
            case ISK.allocsize: {
                .追加!(IR节点_)(数据组, .parseAllocSizeArguments());
                break;
            }
            case ISK.vscale_range: {
                .追加!(IR节点_)(数据组, .parseVScaleRangeArguments());
                break;
            }
            case ISK.preallocated: {
                .追加!(IR节点_)(数据组, .parseRequiredTypeAttr(.当前()));
                break;
            }
            case ISK.alwaysinline:
            case ISK.argmemonly:
            case ISK.builtin:
            case ISK.cold:
            case ISK.convergent:
            case ISK.hot:
            case ISK.inaccessiblememonly:
            case ISK.inaccessiblemem_or_argmemonly:
            case ISK.inlinehint:
            case ISK.jumptable:
            case ISK.minsize:
            case ISK.mustprogress:
            case ISK.naked:
            case ISK.nobuiltin:
            case ISK.nocallback:
            case ISK.nocf_check:
            case ISK.noduplicate:
            case ISK.nofree:
            case ISK.noimplicitfloat:
            case ISK.noinline:
            case ISK.nomerge:
            case ISK.noprofile:
            case ISK.norecurse:
            case ISK.noredzone:
            case ISK.noreturn:
            case ISK.nosanitize_coverage:
            case ISK.nosync:
            case ISK.nounwind:
            case ISK.nonlazybind:
            case ISK.null_pointer_is_valid:
            case ISK.optforfuzzing:
            case ISK.optsize:
            case ISK.optnone:
            case ISK.readnone:
            case ISK.readonly:
            case ISK.returns_twice:
            case ISK.safestack:
            case ISK.sanitize_address:
            case ISK.sanitize_hwaddress:
            case ISK.sanitize_memtag:
            case ISK.sanitize_memory:
            case ISK.sanitize_thread:
            case ISK.shadowcallstack:
            case ISK.speculatable:
            case ISK.speculative_load_hardening:
            case ISK.ssp:
            case ISK.sspreq:
            case ISK.sspstrong:
            case ISK.strictfp:
            case ISK.uwtable:
            case ISK.willreturn:
            case ISK.writeonly: {
                IR节点_ n = .编译IR令牌节点(.当前());
                .追加!(IR节点_)(数据组, n);
                break;
            }
            default: {
                break 循环体;
            }
        }
    }
    基础节点.节点数组_!(IR节点_) 特性组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
    if (InAttrGrp) {
        .编译确定的(ISK.右大括号);
    }
    return 特性组;
}
bool isParamAttrs(ISK isk) {
    switch (isk) {
        case ISK.StringConstant:
        case ISK.align_:
        case ISK.alignstack:
        case ISK.byval:
        case ISK.sret:
        case ISK.preallocated:
        case ISK.inalloca:
        case ISK.dereferenceable:
        case ISK.dereferenceable_or_null:
        case ISK.byref:
        case ISK.inreg:
        case ISK.nest:
        case ISK.noundef:
        case ISK.noalias:
        case ISK.nocapture:
        case ISK.nofree:
        case ISK.nonnull:
        case ISK.readnone:
        case ISK.readonly:
        case ISK.returned:
        case ISK.signext:
        case ISK.swifterror:
        case ISK.swiftself:
        case ISK.swiftasync:
        case ISK.writeonly:
        case ISK.zeroext:
        case ISK.immarg: {
            return true;
        }
        default: break;
    }
    return false;
}
IR节点_ parseRequiredTypeAttr(ISK isk) {
    long 开始 = .获取节点开始();
    .编译确定的(isk);
    .编译确定的(ISK.左括号);
    IR节点_ Ty = .parseType();
    .编译确定的(ISK.右括号);
    if (isk == ISK.byref) {
        IR节点_ n = 工厂.创建按引用设置(Ty);
        return .完成节点!(IR节点_)(n, 开始);
    }
    else if (isk == ISK.sret) {
        IR节点_ n = 工厂.创建结构引用设置(Ty);
        return .完成节点!(IR节点_)(n, 开始);
    }
    else if (isk == ISK.preallocated) {
        IR节点_ n = 工厂.创建预分配设置(Ty);
        return .完成节点!(IR节点_)(n, 开始);
    }
    else if (isk == ISK.inalloca) {
        IR节点_ n = 工厂.创建在内部分配设置(Ty);
        return .完成节点!(IR节点_)(n, 开始);
    }
    else {
        IR节点_ n = 工厂.创建按值设置(Ty);
        return .完成节点!(IR节点_)(n, 开始);
    }
}
基础节点.节点数组_!(IR节点_) parseOptionalParamAttrs() {
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    while(.isParamAttrs(.当前())) {
        switch (.当前()) {
            case ISK.StringConstant: {
                .追加!(IR节点_)(数据组, .parseStringAttribute());
                continue;
            }
            case ISK.align_: {
                .追加!(IR节点_)(cast(IR节点_[])(数据组), .parseOptionalAlignment(true));
                continue;
            }
            case ISK.alignstack: {
                .追加!(IR节点_)(数据组, .parseOptionalStackAlignment());
                continue;
            }
            case ISK.byval: {
                .追加!(IR节点_)(数据组, .parseRequiredTypeAttr(.当前()));
                continue;
            }
            case ISK.sret: {
                .追加!(IR节点_)(数据组, .parseRequiredTypeAttr(.当前()));
                continue;
            }
            case ISK.preallocated: {
                .追加!(IR节点_)(数据组, .parseRequiredTypeAttr(.当前()));
                continue;
            }
            case ISK.inalloca: {
                .追加!(IR节点_)(数据组, .parseRequiredTypeAttr(.当前()));
                continue;
            }
            case ISK.dereferenceable: {
                .追加!(IR节点_)(数据组, .parseOptionalDerefAttrBytes(ISK.dereferenceable));
                continue;
            }
            case ISK.dereferenceable_or_null: {
                .追加!(IR节点_)(数据组, .parseOptionalDerefAttrBytes(ISK.dereferenceable_or_null));
                continue;
            }
            case ISK.byref: {
                .追加!(IR节点_)(数据组, .parseRequiredTypeAttr(.当前()));
                continue;
            }
            case ISK.inreg:
            case ISK.nest:
            case ISK.noundef:
            case ISK.noalias:
            case ISK.nocapture:
            case ISK.nofree:
            case ISK.nonnull:
            case ISK.readnone:
            case ISK.readonly:
            case ISK.returned:
            case ISK.signext:
            case ISK.swifterror:
            case ISK.swiftself:
            case ISK.swiftasync:
            case ISK.writeonly:
            case ISK.zeroext:
            case ISK.immarg: {
                IR节点_ nk = .编译IR令牌节点(.当前());
                .追加!(IR节点_)(数据组, nk);
                break;
            }
            default: break;
        }
    }
    return .创建节点数组!(IR节点_)(数据组, 数组开始);
}
对齐堆栈设置_ parseOptionalStackAlignment() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.alignstack);
    .编译确定的(ISK.左括号);
    IR数字字面量_ Val = .parseUInt32();
    .编译确定的(ISK.右括号);
    对齐堆栈设置_ n = 工厂.创建对齐堆栈设置(Val);
    return .完成节点!(对齐堆栈设置_)(n, 开始);
}
分配大小设置_ parseAllocSizeArguments() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.allocsize);
    .编译确定的(ISK.左括号);
    long 值开始 = .获取节点开始();
    IR数字字面量_ V1 = .parseUInt32();
    IR数字字面量_ V2;
    if (.编译可选的(ISK.逗号)) {
        V2 = .parseUInt32();
    }
    分配大小设置内容_ Val = 工厂.创建分配大小设置内容(V1, V2);
    .完成节点!(分配大小设置内容_)(Val, 值开始);
    .编译确定的(ISK.右括号);
    分配大小设置_ n = 工厂.创建分配大小设置(Val);
    return .完成节点!(分配大小设置_)(n, 开始);
}
倍数范围设置_ parseVScaleRangeArguments() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.vscale_range);
    .编译确定的(ISK.左括号);
    long 值开始 = .获取节点开始();
    IR数字字面量_ V1 = .parseUInt32();
    IR数字字面量_ V2;
    if (.编译可选的(ISK.逗号)) {
        V2 = .parseUInt32();
    }
    倍数范围设置内容_ Val = 工厂.创建倍数范围设置内容(V1, V2);
    .完成节点!(倍数范围设置内容_)(Val, 值开始);
    .编译确定的(ISK.右括号);
    倍数范围设置_ n = 工厂.创建倍数范围设置(Val);
    return .完成节点!(倍数范围设置_)(n, 开始);
}
地址空间设置_ parseOptionalAddrSpace() {
    if (.当前() != ISK.addrspace) {
        return ··null!(地址空间设置_);
    }
    long 开始 = .获取节点开始();
    .编译确定的(ISK.addrspace);
    .编译确定的(ISK.左括号);
    IR数字字面量_ Val = .parseUInt32();
    .编译确定的(ISK.右括号);
    地址空间设置_ n = 工厂.创建地址空间设置(Val);
    return .完成节点!(地址空间设置_)(n, 开始);
}
IR节点_ parseOptionalUnnamedAddr() {
    long 开始 = .获取节点开始();
    if (.当前() == ISK.unnamed_addr) {
        return .编译IR令牌节点(.当前());
    }
    if (.当前() == ISK.local_unnamed_addr) {
        return .编译IR令牌节点(.当前());
    }
    return ··null!(IR节点_);
}
IR节点_ parseOptionalComdat() {
    if (.当前() != ISK.comdat) {
        return ··null!(IR节点_);
    }
    long 开始 = .获取节点开始();
    .编译确定的(ISK.comdat);
    if (.编译可选的(ISK.左括号)) {
        IR文本字面量_ Val = .getStrVal();
        .编译确定的(ISK.右括号);
        封装设置_ n = 工厂.创建封装设置(Val);
        return .完成节点!(封装设置_)(n, 开始);
    }
    封装设置_ nn = 工厂.创建封装设置();
    return .完成节点!(封装设置_)(nn, 开始);
}
结构类型_ parseAnonStructType(long 开始, bool Packed) {
    基础节点.节点数组_!(IR节点_) 元素组 = .parseStructBody();
    结构类型_ n = 工厂.创建结构类型(元素组);
    n.是压缩的 = Packed;
    return .完成节点!(结构类型_)(n, 开始);
}
基础节点.节点数组_!(IR节点_) parseStructBody() {
    bool delegate(IR节点_) isValidElementType;
    long 数组开始;
    IR节点_[] 数据组;
    IR节点_ Ty;
    基础节点.节点数组_!(IR节点_) 元素组;
    bool isValidElementType·func(IR节点_ n) {
        return n.目标种类 != ISK.void_ && n.目标种类 != ISK.label && n.目标种类 != ISK.metadata && n.目标种类 != ISK.函数类型 && n.目标种类 != ISK.token;
    }
    isValidElementType = &isValidElementType·func;
    .编译确定的(ISK.左大括号);
    if (.编译可选的(ISK.右大括号)) {
        return ··null!(基础节点.节点数组_!(IR节点_));
    }
    数组开始 = .获取节点开始();
    数据组 = 创建数组!(IR节点_)();
    Ty = .parseType();
    if (!isValidElementType(Ty)) {
        .编译错误在(Ty.开始, Ty.结束, 诊断集_.nvalid_element_type_for_struct, ""d);
    }
    .追加!(IR节点_)(数据组, Ty);
    while(.编译可选的(ISK.逗号)) {
        Ty = .parseType();
        if (!isValidElementType(Ty)) {
            .编译错误在(Ty.开始, Ty.结束, 诊断集_.nvalid_element_type_for_struct, ""d);
        }
        .追加!(IR节点_)(数据组, Ty);
    }
    元素组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
    .编译确定的(ISK.右大括号);
    return 元素组;
}
IR节点_ parseArrayVectorType(long 开始, bool IsVector) {
    bool delegate(IR节点_) 是有效的向量类型;
    bool delegate(IR节点_) isValidArrayElementType;
    IR节点_ V;
    IR数字字面量_ Size;
    IR节点_ ty;
    bool 是有效的向量类型·func(IR节点_ ty) {
        return ty.目标种类 == ISK.整数类型 || ty.目标种类 == ISK.指针类型 || ty.目标种类 == ISK.half || ty.目标种类 == ISK.bfloat || ty.目标种类 == ISK.float_ || ty.目标种类 == ISK.double_ || ty.目标种类 == ISK.x86_fp80 || ty.目标种类 == ISK.fp128 || ty.目标种类 == ISK.ppc_fp128 || ty.目标种类 == ISK.x86_mmx || ty.目标种类 == ISK.x86_amx;
    }
    是有效的向量类型 = &是有效的向量类型·func;
    bool isValidArrayElementType·func(IR节点_ n) {
        return n.目标种类 != ISK.void_ && n.目标种类 != ISK.label && n.目标种类 != ISK.metadata && n.目标种类 != ISK.函数类型 && n.目标种类 != ISK.token && n.目标种类 != ISK.x86_amx && !.是可扩展的向量类型(n);
    }
    isValidArrayElementType = &isValidArrayElementType·func;
    if (IsVector && .当前() == ISK.vscale) {
        V = .编译确定IR令牌!(ISK)(ISK.vscale);
        .编译确定的(ISK.x);
    }
    Size = .getAPSIntVal();
    .编译确定的(ISK.x);
    ty = .parseType();
    .编译确定的(IsVector ? ISK.右尖括号 : ISK.右方括号);
    if (IsVector) {
        if (!是有效的向量类型(ty)) {
            .编译错误在(ty.开始, ty.结束, 诊断集_.invalid_array_element_type, ""d);
        }
        向量类型_ n = 工厂.创建向量类型(ty, Size, V);
        return .完成节点!(向量类型_)(n, 开始);
    }
    else {
        if (!isValidArrayElementType(ty)) {
            .编译错误在(ty.开始, ty.结束, 诊断集_.invalid_array_element_type, ""d);
        }
        数组类型_ n = 工厂.创建数组类型(ty, Size);
        return .完成节点!(数组类型_)(n, 开始);
    }
}
bool 是可扩展的向量类型(IR节点_ n) {
    if (n.目标种类 == ISK.向量类型) {
        return (cast(向量类型_)(n)).是可扩展的;
    }
    return false;
}
全局表达式_ parseGlobalTypeAndValue(IR节点_ InRangeOp = ··null!(IR节点_)) {
    long 开始 = InRangeOp ? InRangeOp.开始 : .获取节点开始();
    IR节点_ type = .parseType();
    IR节点_ 表达式 = .parseValID();
    全局表达式_ n = 工厂.创建全局表达式(type, 表达式, InRangeOp);
    return .完成节点!(全局表达式_)(n, 开始);
}
IR标识符_ 创建ValID(标识符分类_ idk, 字面量类表达式基类_ 内容) {
    if (内容.目标种类 == ISK.数字字面量) {
        IR数字字面量_ id = (cast(IR数字字面量_)(内容));
        IR标识符_ 标识符 = 工厂.创建IR标识符(idk | 标识符分类_.ID标识符_, id);
        标识符.开始 = id.开始;
        标识符.结束 = id.结束;
        return 标识符;
    }
    else {
        IR文本字面量_ id = (cast(IR文本字面量_)(内容));
        IR标识符_ 标识符 = 工厂.创建IR标识符(idk, id);
        标识符.开始 = id.开始;
        标识符.结束 = id.结束;
        return 标识符;
    }
}
IR节点_ parseValID() {
    switch (.当前()) {
        case ISK.GlobalID: {
            IR数字字面量_ val = .getUIntVal();
            return .创建ValID(标识符分类_.全局标识符_, val);
        }
        case ISK.GlobalVar: {
            IR文本字面量_ val = .getStrVal();
            return .创建ValID(.获取标识符分类(val, 标识符分类_.全局标识符_), val);
        }
        case ISK.LocalVarID: {
            IR数字字面量_ val = .getUIntVal();
            return .创建ValID(标识符分类_.局部标识符_, val);
        }
        case ISK.LocalVar: {
            IR文本字面量_ val = .getStrVal();
            return .创建ValID(.获取标识符分类(val, 标识符分类_.局部标识符_), val);
        }
        case ISK.APSInt: {
            return .getAPSIntVal();
        }
        case ISK.APFloat: {
            return .getAPFloatVal();
        }
        case ISK.true_:
        case ISK.false_:
        case ISK.null_:
        case ISK.undef:
        case ISK.poison:
        case ISK.zeroinitializer:
        case ISK.none: {
            return .编译IR令牌节点(.当前());
        }
        case ISK.左大括号: {
            return .编译结构常量表达式();
        }
        case ISK.左尖括号: {
            return .编译压缩结构常量表达式或向量常量表达式();
        }
        case ISK.左方括号: {
            return .编译数组常量表达式();
        }
        case ISK.c: {
            return .编译c文本常量();
        }
        case ISK.asm_: {
            return .编译asm();
        }
        case ISK.blockaddress: {
            return .编译块地址组();
        }
        case ISK.dso_local_equivalent: {
            return .编译DSO局部等效常量表达式();
        }
        case ISK.trunc:
        case ISK.zext:
        case ISK.sext:
        case ISK.fptrunc:
        case ISK.fpext:
        case ISK.bitcast:
        case ISK.addrspacecast:
        case ISK.uitofp:
        case ISK.sitofp:
        case ISK.fptoui:
        case ISK.fptosi:
        case ISK.inttoptr:
        case ISK.ptrtoint: {
            return .编译转换类常量表达式();
        }
        case ISK.extractvalue: {
            return .编译提取值常量表达式();
        }
        case ISK.insertvalue: {
            return .编译插入值常量表达式();
        }
        case ISK.icmp:
        case ISK.fcmp: {
            return .编译比较类常量表达式();
        }
        case ISK.fneg: {
            return .编译取反常量表达式();
        }
        case ISK.add:
        case ISK.fadd:
        case ISK.sub:
        case ISK.fsub:
        case ISK.mul:
        case ISK.fmul:
        case ISK.udiv:
        case ISK.sdiv:
        case ISK.fdiv:
        case ISK.urem:
        case ISK.srem:
        case ISK.frem:
        case ISK.shl:
        case ISK.lshr:
        case ISK.ashr: {
            return .编译二元常量表达式();
        }
        case ISK.and:
        case ISK.or:
        case ISK.xor: {
            return .编译逻辑常量表达式();
        }
        case ISK.getelementptr: {
            return .编译获取元素指针常量表达式();
        }
        case ISK.shufflevector: {
            return .编译向量洗牌常量表达式();
        }
        case ISK.insertelement: {
            return .编译插入元素常量表达式();
        }
        case ISK.extractelement: {
            return .编译提取元素常量表达式();
        }
        case ISK.select: {
            return .编译选择常量表达式();
        }
        default: {
            return .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.expected_0_predicate);
        }
    }
}
结构常量表达式_ 编译结构常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.左大括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    bool 第一层 = false;
    while(!第一层 || .编译可选的(ISK.逗号)) {
        第一层 = true;
        全局表达式_ C = .parseGlobalTypeAndValue();
        .追加!(IR节点_)(数据组, C);
    }
    基础节点.节点数组_!(IR节点_) 元素组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
    .编译确定的(ISK.右大括号);
    结构常量表达式_ 常量表达式 = 工厂.创建结构常量表达式(元素组);
    return .完成节点!(结构常量表达式_)(常量表达式, 开始);
}
IR节点_ 编译压缩结构常量表达式或向量常量表达式() {
    .编译确定的(ISK.左尖括号);
    long 开始 = .获取节点开始();
    基础节点.节点数组_!(IR节点_) 元素组;
    if (.编译可选的(ISK.左大括号)) {
        long 数组开始 = .获取节点开始();
        IR节点_[] 数据组 = 创建数组!(IR节点_)();
        bool 第一层 = false;
        while(!第一层 || .编译可选的(ISK.逗号)) {
            第一层 = true;
            全局表达式_ C = .parseGlobalTypeAndValue();
            .追加!(IR节点_)(数据组, C);
        }
        元素组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
        .编译确定的(ISK.右大括号);
        .编译确定的(ISK.右尖括号);
        结构常量表达式_ 常量表达式 = 工厂.创建结构常量表达式(元素组, /* 是压缩的 */ true);
        return .完成节点!(结构常量表达式_)(常量表达式, 开始);
    }
    else {
        long 数组开始 = .获取节点开始();
        IR节点_[] 数据组 = 创建数组!(IR节点_)();
        bool 第一层 = false;
        while(!第一层 || .编译可选的(ISK.逗号)) {
            第一层 = true;
            全局表达式_ C = .parseGlobalTypeAndValue();
            .追加!(IR节点_)(数据组, C);
        }
        元素组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
        .编译确定的(ISK.右尖括号);
        向量常量表达式_ 向量表达式 = 工厂.创建向量常量表达式(元素组);
        return .完成节点!(向量常量表达式_)(向量表达式, 开始);
    }
}
数组常量表达式_ 编译数组常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.左方括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    bool 第一层 = false;
    while(!第一层 || .编译可选的(ISK.逗号)) {
        第一层 = true;
        全局表达式_ C = .parseGlobalTypeAndValue();
        .追加!(IR节点_)(数据组, C);
    }
    基础节点.节点数组_!(IR节点_) 元素组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
    .编译确定的(ISK.右方括号);
    数组常量表达式_ 常量表达式 = 工厂.创建数组常量表达式(元素组);
    return .完成节点!(数组常量表达式_)(常量表达式, 开始);
}
c文本常量_ 编译c文本常量() {
    long 开始 = .获取节点开始();
    bool 储存 = .解码为c文本常量;
    .解码为c文本常量 = true;
    .编译确定的(ISK.c);
    .解码为c文本常量 = 储存;
    IRc文本字面量_ val = .getCstrVal();
    c文本常量_ n = 工厂.创建c文本常量(val);
    return .完成节点!(c文本常量_)(n, 开始);
}
内联汇编常量表达式_ 编译asm() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.asm_);
    IR节点_ HasSideEffect;
    IR节点_ AlignStack;
    IR节点_ AsmDialect;
    IR节点_ CanThrow;
    if (.当前() == ISK.sideeffect) {
        HasSideEffect = .编译IR令牌节点(.当前());
    }
    if (.当前() == ISK.alignstack) {
        AlignStack = .编译IR令牌节点(.当前());
    }
    if (.当前() == ISK.inteldialect) {
        AsmDialect = .编译IR令牌节点(.当前());
    }
    if (.当前() == ISK.unwind) {
        CanThrow = .编译IR令牌节点(.当前());
    }
    IR文本字面量_ str0 = .parseStringConstant();
    .编译确定的(ISK.逗号);
    IR文本字面量_ str1 = .parseStringConstant();
    内联汇编常量表达式_ n = 工厂.创建内联汇编常量表达式(str0, str1, HasSideEffect, AlignStack, AsmDialect, CanThrow);
    return .完成节点!(内联汇编常量表达式_)(n, 开始);
}
块地址表常量表达式_ 编译块地址组() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.blockaddress);
    .编译确定的(ISK.左括号);
    IR节点_ fn = .parseValID();
    .编译确定的(ISK.逗号);
    IR节点_ label = .parseValID();
    .编译确定的(ISK.右括号);
    块地址表常量表达式_ n = 工厂.创建块地址表常量表达式(fn, label);
    return .完成节点!(块地址表常量表达式_)(n, 开始);
}
DSO局部等效常量表达式_ 编译DSO局部等效常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.dso_local_equivalent);
    IR节点_ fn = .parseValID();
    DSO局部等效常量表达式_ n = 工厂.创建DSO局部等效常量表达式(fn);
    return .完成节点!(DSO局部等效常量表达式_)(n, 开始);
}
常量转换类节点_ 编译转换类常量表达式() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) kind = .编译确定IR令牌!(ISK)(.当前());
    .编译确定的(ISK.左括号);
    全局表达式_ srcVal = .parseGlobalTypeAndValue();
    .编译确定的(ISK.to);
    IR节点_ DestTy = .parseType();
    .编译确定的(ISK.右括号);
    常量转换类节点_ n = 工厂.创建常量转换类节点(kind, srcVal, DestTy);
    return .完成节点!(常量转换类节点_)(n, 开始);
}
提取值常量表达式_ 编译提取值常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.extractvalue);
    .编译确定的(ISK.左括号);
    全局表达式_ Val = .parseGlobalTypeAndValue();
    基础节点.节点数组_!(IR节点_) Indices = .parseIndexList();
    .编译确定的(ISK.右括号);
    提取值常量表达式_ n = 工厂.创建提取值常量表达式(Val, Indices);
    return .完成节点!(提取值常量表达式_)(n, 开始);
}
基础节点.节点数组_!(IR节点_) parseIndexList() {
    long 开始 = .获取节点开始();
    IR节点_[] 结果组 = 创建数组!(IR节点_)();
    while(.编译可选的(ISK.逗号)) {
        assert(.当前() == ISK.数字字面量, "xxx"c);
        IR数字字面量_ n = .getUIntVal();
        .追加!(IR节点_)(结果组, n);
    }
    return .创建节点数组!(IR节点_)(结果组, 开始);
}
插入值常量表达式_ 编译插入值常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.insertvalue);
    .编译确定的(ISK.左括号);
    全局表达式_ Val0 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val1 = .parseGlobalTypeAndValue();
    基础节点.节点数组_!(IR节点_) Indices = .parseIndexList();
    .编译确定的(ISK.右括号);
    插入值常量表达式_ n = 工厂.创建插入值常量表达式(Val0, Val1, Indices);
    return .完成节点!(插入值常量表达式_)(n, 开始);
}
比较类常量表达式_ 编译比较类常量表达式() {
    long 开始 = .获取节点开始();
    ISK kind = .当前();
    IR节点_ kindN = .编译IR令牌节点(kind);
    IR节点_ PredVal = .parseCmpPredicate(kind);
    .编译确定的(ISK.左括号);
    全局表达式_ Val0 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val1 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.右括号);
    比较类常量表达式_ n = 工厂.创建比较类常量表达式(kindN, PredVal, Val0, Val1);
    return .完成节点!(比较类常量表达式_)(n, 开始);
}
IR节点_ parseCmpPredicate(ISK kind) {
    long 开始 = .获取节点开始();
    if (kind == ISK.fcmp) {
        switch (.当前()) {
            case ISK.oeq:
            case ISK.one:
            case ISK.olt:
            case ISK.ogt:
            case ISK.ole:
            case ISK.oge:
            case ISK.ord:
            case ISK.uno:
            case ISK.ueq:
            case ISK.une:
            case ISK.ult:
            case ISK.ugt:
            case ISK.ule:
            case ISK.uge:
            case ISK.true_:
            case ISK.false_: {
                return .编译IR令牌节点(.当前());
            }
            default: {
                return .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.expected_0_predicate);
            }
        }
    }
    else {
        switch (.当前()) {
            case ISK.eq:
            case ISK.ne:
            case ISK.slt:
            case ISK.sgt:
            case ISK.sle:
            case ISK.sge:
            case ISK.ult:
            case ISK.ugt:
            case ISK.ule:
            case ISK.uge: {
                return .编译IR令牌节点(.当前());
            }
            default: {
                return .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.expected_0_predicate);
            }
        }
    }
}
取反常量表达式_ 编译取反常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.fneg);
    .编译确定的(ISK.左括号);
    全局表达式_ Val0 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.右括号);
    取反常量表达式_ n = 工厂.创建取反常量表达式(Val0);
    return .完成节点!(取反常量表达式_)(n, 开始);
}
二元常量表达式_ 编译二元常量表达式() {
    long 开始 = .获取节点开始();
    ISK kind = .当前();
    IR令牌_!(ISK) Opc = .编译确定IR令牌!(ISK)(kind);
    IR节点_ NUW;
    IR节点_ NSW;
    IR节点_ Exact;
    if (kind == ISK.add || kind == ISK.sub || kind == ISK.mul || kind == ISK.shl) {
        if (.当前() == ISK.nuw) {
            NUW = .编译IR令牌节点(.当前());
        }
        if (.当前() == ISK.nsw) {
            NSW = .编译IR令牌节点(.当前());
            if (.当前() == ISK.nuw) {
                NUW = .编译IR令牌节点(.当前());
            }
        }
    }
    else if (kind == ISK.sdiv || kind == ISK.udiv || kind == ISK.lshr || kind == ISK.ashr) {
        if (.当前() == ISK.exact) {
            Exact = .编译IR令牌节点(.当前());
        }
    }
    .编译确定的(ISK.左括号);
    全局表达式_ Val0 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val1 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.右括号);
    二元常量表达式_ n = 工厂.创建二元常量表达式(Opc, Val0, Val1, NUW, NSW, Exact);
    return .完成节点!(二元常量表达式_)(n, 开始);
}
逻辑类常量表达式_ 编译逻辑常量表达式() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) Opc = .编译确定IR令牌!(ISK)(.当前());
    .编译确定的(ISK.左括号);
    全局表达式_ Val0 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val1 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.右括号);
    逻辑类常量表达式_ n = 工厂.创建逻辑类常量表达式(Opc, Val0, Val1);
    return .完成节点!(逻辑类常量表达式_)(n, 开始);
}
获取元素指针常量表达式_ 编译获取元素指针常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.getelementptr);
    IR节点_ InBounds;
    if (.当前() == ISK.inbounds) {
        InBounds = .编译IR令牌节点(.当前());
    }
    .编译确定的(ISK.左括号);
    IR节点_ ty = .parseType();
    .编译确定的(ISK.逗号);
    基础节点.节点数组_!(IR节点_) Elts = .编译全局值范围运算();
    获取元素指针常量表达式_ n = 工厂.创建获取元素指针常量表达式(ty, Elts, InBounds);
    return .完成节点!(获取元素指针常量表达式_)(n, 开始);
}
基础节点.节点数组_!(IR节点_) 编译全局值范围运算() {
    bool 第一层 = false;
    long 数组开始 = .获取节点开始();
    IR节点_[] 数据组 = 创建数组!(IR节点_)();
    while(!第一层 || .编译可选的(ISK.逗号)) {
        第一层 = true;
        IR节点_ InRangeOp;
        if (.当前() == ISK.inrange) {
            InRangeOp = .编译IR令牌节点(.当前());
        }
        全局表达式_ n = .parseGlobalTypeAndValue(InRangeOp);
        .追加!(IR节点_)(数据组, n);
    }
    基础节点.节点数组_!(IR节点_) 元素组 = .创建节点数组!(IR节点_)(数据组, 数组开始);
    .编译确定的(ISK.右括号);
    return 元素组;
}
向量洗牌常量表达式_ 编译向量洗牌常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.shufflevector);
    .编译确定的(ISK.左括号);
    全局表达式_ Val0 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val1 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val2 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.右括号);
    向量洗牌常量表达式_ n = 工厂.创建向量洗牌常量表达式(Val0, Val1, Val2);
    return .完成节点!(向量洗牌常量表达式_)(n, 开始);
}
插入元素常量表达式_ 编译插入元素常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.insertelement);
    .编译确定的(ISK.左括号);
    全局表达式_ Val0 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val1 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val2 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.右括号);
    插入元素常量表达式_ n = 工厂.创建插入元素常量表达式(Val0, Val1, Val2);
    return .完成节点!(插入元素常量表达式_)(n, 开始);
}
提取元素常量表达式_ 编译提取元素常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.extractelement);
    .编译确定的(ISK.左括号);
    全局表达式_ Val0 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val1 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.右括号);
    提取元素常量表达式_ n = 工厂.创建提取元素常量表达式(Val0, Val1);
    return .完成节点!(提取元素常量表达式_)(n, 开始);
}
选择常量表达式_ 编译选择常量表达式() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.select);
    .编译确定的(ISK.左括号);
    全局表达式_ Val0 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val1 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.逗号);
    全局表达式_ Val2 = .parseGlobalTypeAndValue();
    .编译确定的(ISK.右括号);
    选择常量表达式_ n = 工厂.创建选择常量表达式(Val0, Val1, Val2);
    return .完成节点!(选择常量表达式_)(n, 开始);
}
IR节点_ parseSummaryEntry() {
    IR数字字面量_ id = .getUIntVal();
    IR标识符_ SummaryID = 工厂.创建IR标识符(标识符分类_.摘要标识符_ | 标识符分类_.ID标识符_, id);
    .冒号是标识符 = true;
    IR节点_ result;
    .编译确定的(ISK.等号);
    if (.跳过摘要) {
        .skipModuleSummaryEntry();
        .冒号是标识符 = false;
        return ··null!(IR节点_);
    }
    switch (.当前()) {
        case ISK.gv: {
            result = .parseGVEntry();
            break;
        }
        case ISK.module_: {
            result = .parseModuleEntry();
            break;
        }
        case ISK.typeid_: {
            result = .parseTypeIdEntry();
            break;
        }
        case ISK.typeidCompatibleVTable: {
            result = .parseTypeIdCompatibleVtableEntry();
            break;
        }
        case ISK.flags: {
            result = .parseSummaryIndexFlags();
            break;
        }
        case ISK.blockcount: {
            result = .parseBlockCount();
            break;
        }
        default: break;
    }
    .冒号是标识符 = false;
    全局摘要声明_ n = 工厂.创建全局摘要声明(SummaryID, result);
    return .完成节点!(全局摘要声明_)(n, SummaryID.开始);
}
void skipModuleSummaryEntry() {
    switch (.当前()) {
        case ISK.gv:
        case ISK.module_:
        case ISK.typeid_:
        case ISK.typeidCompatibleVTable:
        case ISK.flags:
        case ISK.blockcount: {
            break;
        }
        default: {
            .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
            return;
        }
    }
    if (.当前() == ISK.flags) {
        .parseSummaryIndexFlags();
        return;
    }
    if (.当前() == ISK.blockcount) {
        .parseBlockCount();
        return;
    }
    .下个();
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    int NumOpenParen = 1;
    bool 应循环 = true;
    while(应循环) {
        switch (.当前()) {
            case ISK.左括号: {
                ++NumOpenParen;
                break;
            }
            case ISK.右括号: {
                --NumOpenParen;
                break;
            }
            case ISK.文件结尾: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                return;
            }
            default: {
                break;
            }
        }
        .下个();
        应循环 = NumOpenParen > 0;
    }
    return;
}
摘要值设置_ parseBlockCount() {
    long 开始 = .获取节点开始();
    IR节点_ k = .编译IR令牌节点(ISK.blockcount);
    .编译确定的(ISK.冒号);
    IR数字字面量_ BlockCount = .parseUInt64();
    摘要值设置_ n = 工厂.创建摘要值设置(k, BlockCount);
    return .完成节点!(摘要值设置_)(n, 开始);
}
摘要值设置_ parseSummaryIndexFlags() {
    long 开始 = .获取节点开始();
    IR节点_ k = .编译IR令牌节点(ISK.flags);
    .编译确定的(ISK.冒号);
    IR数字字面量_ Flags = .parseUInt64();
    摘要值设置_ n = 工厂.创建摘要值设置(k, Flags);
    return .完成节点!(摘要值设置_)(n, 开始);
}
类型id兼容表摘要_ parseTypeIdCompatibleVtableEntry() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.typeidCompatibleVTable);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long namek = .获取节点开始();
    IR节点_ k = .编译IR令牌节点(ISK.name);
    .编译确定的(ISK.冒号);
    IR文本字面量_ Name = .parseStringConstant();
    摘要值设置_ name = 工厂.创建摘要值设置(k, Name);
    .完成节点!(摘要值设置_)(name, namek);
    .编译确定的(ISK.逗号);
    long 摘要开始 = .获取节点开始();
    IR节点_ sk = .编译IR令牌节点(ISK.summary);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        long k2 = .获取节点开始();
        .编译确定的(ISK.左括号);
        long ofp = .获取节点开始();
        IR节点_ ofk = .编译IR令牌节点(ISK.offset);
        .编译确定的(ISK.冒号);
        IR数字字面量_ Offset = .parseUInt64();
        摘要值设置_ ofn = 工厂.创建摘要值设置(ofk, Offset);
        .完成节点!(摘要值设置_)(ofn, ofp);
        .编译确定的(ISK.逗号);
        全局值引用摘要_ VI = .parseGVReference();
        .编译确定的(ISK.右括号);
        偏移及引用_ ofv = 工厂.创建偏移及引用(ofn, VI);
        .追加!(IR节点_)(值组, .完成节点!(偏移及引用_)(ofv, k2));
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ summary = 工厂.创建摘要多值设置(sk, 设置值);
    .完成节点!(摘要多值设置_)(summary, 摘要开始);
    .编译确定的(ISK.右括号);
    类型id兼容表摘要_ n = 工厂.创建类型id兼容表摘要(name, summary);
    return .完成节点!(类型id兼容表摘要_)(n, 开始);
}
类型id内容摘要_ parseTypeIdEntry() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.typeid_);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    .编译确定的(ISK.name);
    .编译确定的(ISK.冒号);
    IR文本字面量_ Name = .parseStringConstant();
    .编译确定的(ISK.逗号);
    摘要多值设置_ TIS = .parseTypeIdSummary();
    .编译确定的(ISK.左括号);
    类型id内容摘要_ n = 工厂.创建类型id内容摘要(Name, TIS);
    return .完成节点!(类型id内容摘要_)(n, 开始);
}
摘要多值设置_ parseTypeIdSummary() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(ISK.summary);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    摘要多值设置_ TTRes = .parseTypeTestResolution();
    .追加!(IR节点_)(值组, TTRes);
    if (.编译可选的(ISK.逗号)) {
        摘要多值设置_ WPDRes = .parseOptionalWpdResolutions();
        .追加!(IR节点_)(值组, WPDRes);
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置值);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
摘要多值设置_ parseTypeTestResolution() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(ISK.typeTestRes);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    IR节点_ 键1 = .编译IR令牌节点(ISK.kind);
    .编译确定的(ISK.冒号);
    IR节点_ 值1;
    switch (.当前()) {
        case ISK.unknown:
        case ISK.unsat:
        case ISK.byteArray:
        case ISK.inline:
        case ISK.single:
        case ISK.allOnes: {
            值1 = .编译IR令牌节点(.当前());
            break;
        }
        default: {
            .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
            break;
        }
    }
    摘要值设置_ 设置值1 = 工厂.创建摘要值设置(键1, 值1);
    .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(设置值1, 数组开始));
    .编译确定的(ISK.逗号);
    long 开始2 = .获取节点开始();
    IR节点_ 键2 = .编译IR令牌节点(ISK.sizeM1BitWidth);
    .编译确定的(ISK.冒号);
    IR数字字面量_ 值2 = .parseUInt32();
    摘要值设置_ 设置值2 = 工厂.创建摘要值设置(键2, 值2);
    .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(设置值2, 开始2));
    while(.编译可选的(ISK.逗号)) {
        switch (.当前()) {
            case ISK.alignLog2: {
                long 开始3 = .获取节点开始();
                IR节点_ 键3 = .编译IR令牌节点(ISK.alignLog2);
                .编译确定的(ISK.冒号);
                IR数字字面量_ 值3 = .parseUInt64();
                摘要值设置_ 设置值3 = 工厂.创建摘要值设置(键3, 值3);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(设置值3, 开始3));
                break;
            }
            case ISK.sizeM1: {
                long 开始3 = .获取节点开始();
                IR节点_ 键3 = .编译IR令牌节点(ISK.sizeM1);
                .编译确定的(ISK.冒号);
                IR数字字面量_ 值3 = .parseUInt64();
                摘要值设置_ 设置值3 = 工厂.创建摘要值设置(键3, 值3);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(设置值3, 开始3));
                break;
            }
            case ISK.bitMask: {
                long 开始3 = .获取节点开始();
                IR节点_ 键3 = .编译IR令牌节点(ISK.bitMask);
                .编译确定的(ISK.冒号);
                IR数字字面量_ 值3 = .parseUInt32();
                摘要值设置_ 设置值3 = 工厂.创建摘要值设置(键3, 值3);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(设置值3, 开始3));
                break;
            }
            case ISK.inlineBits: {
                long 开始3 = .获取节点开始();
                IR节点_ 键3 = .编译IR令牌节点(ISK.inlineBits);
                .编译确定的(ISK.冒号);
                IR数字字面量_ 值3 = .parseUInt64();
                摘要值设置_ 设置值3 = 工厂.创建摘要值设置(键3, 值3);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(设置值3, 开始3));
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置值);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
摘要多值设置_ parseOptionalWpdResolutions() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(ISK.wpdResolutions);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        long 设置开始 = .获取节点开始();
        .编译确定的(ISK.左括号);
        long 偏移开始 = .获取节点开始();
        IR节点_ 偏移键 = .编译IR令牌节点(ISK.offset);
        .编译确定的(ISK.冒号);
        IR数字字面量_ Offset = .parseUInt64();
        摘要值设置_ 偏移 = 工厂.创建摘要值设置(偏移键, Offset);
        .完成节点!(摘要值设置_)(偏移, 偏移开始);
        .编译确定的(ISK.逗号);
        摘要多值设置_ WPDRes = .parseWpdRes();
        .编译确定的(ISK.右括号);
        偏移及引用_ 值 = 工厂.创建偏移及引用(偏移, WPDRes);
        .完成节点!(偏移及引用_)(值, 设置开始);
        .追加!(IR节点_)(值组, 值);
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置值);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
摘要多值设置_ parseWpdRes() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(ISK.wpdRes);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    IR节点_ k = .编译IR令牌节点(ISK.kind);
    .编译确定的(ISK.冒号);
    IR节点_ kn;
    switch (.当前()) {
        case ISK.indir:
        case ISK.singleImpl:
        case ISK.branchFunnel: {
            kn = .编译IR令牌节点(.当前());
            break;
        }
        default: {
            .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
            break;
        }
    }
    摘要值设置_ 值1 = 工厂.创建摘要值设置(k, kn);
    .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值1, 数组开始));
    while(.编译可选的(ISK.逗号)) {
        switch (.当前()) {
            case ISK.singleImplName: {
                long k2 = .获取节点开始();
                IR节点_ kk = .编译IR令牌节点(ISK.singleImplName);
                .编译确定的(ISK.冒号);
                IR文本字面量_ kz = .parseStringConstant();
                摘要值设置_ kn2 = 工厂.创建摘要值设置(kk, kz);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(kn2, k2));
                break;
            }
            case ISK.resByArg: {
                摘要多值设置_ ResByArg = .parseOptionalResByArg();
                .追加!(IR节点_)(值组, ResByArg);
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置值);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
摘要多值设置_ parseOptionalResByArg() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.resByArg);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    bool 应循环 = true;
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    while(应循环) {
        摘要多值设置_ Args = .parseArgs();
        .编译确定的(ISK.逗号);
        long bap = .获取节点开始();
        IR令牌_!(ISK) bak = .编译确定IR令牌!(ISK)(ISK.byArg);
        .编译确定的(ISK.冒号);
        .编译确定的(ISK.左括号);
        long baksk = .获取节点开始();
        IR节点_[] baks = 创建数组!(IR节点_)();
        IR令牌_!(ISK) kin = .编译确定IR令牌!(ISK)(ISK.kind);
        .编译确定的(ISK.冒号);
        IR节点_ kinn;
        switch (.当前()) {
            case ISK.indir:
            case ISK.uniformRetVal:
            case ISK.uniqueRetVal:
            case ISK.virtualConstProp: {
                kinn = .编译IR令牌节点(.当前());
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
        摘要值设置_ 值0 = 工厂.创建摘要值设置(kin, kinn);
        .追加!(IR节点_)(baks, .完成节点!(摘要值设置_)(值0, baksk));
        while(.编译可选的(ISK.逗号)) {
            switch (.当前()) {
                case ISK.info: {
                    long 值1p = .获取节点开始();
                    IR令牌_!(ISK) 值1k = .编译确定IR令牌!(ISK)(ISK.info);
                    .编译确定的(ISK.冒号);
                    IR数字字面量_ 值1z = .parseUInt64();
                    摘要值设置_ 值1 = 工厂.创建摘要值设置(值1k, 值1z);
                    .追加!(IR节点_)(baks, .完成节点!(摘要值设置_)(值1, 值1p));
                    break;
                }
                case ISK.byte_: {
                    long 值1p = .获取节点开始();
                    IR令牌_!(ISK) 值1k = .编译确定IR令牌!(ISK)(ISK.byte_);
                    .编译确定的(ISK.冒号);
                    IR数字字面量_ 值1z = .parseUInt32();
                    摘要值设置_ 值1 = 工厂.创建摘要值设置(值1k, 值1z);
                    .追加!(IR节点_)(baks, .完成节点!(摘要值设置_)(值1, 值1p));
                    break;
                }
                case ISK.bit: {
                    long 值1p = .获取节点开始();
                    IR令牌_!(ISK) 值1k = .编译确定IR令牌!(ISK)(ISK.bit);
                    .编译确定的(ISK.冒号);
                    IR数字字面量_ 值1z = .parseUInt32();
                    摘要值设置_ 值1 = 工厂.创建摘要值设置(值1k, 值1z);
                    .追加!(IR节点_)(baks, .完成节点!(摘要值设置_)(值1, 值1p));
                    break;
                }
                default: {
                    .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                    break;
                }
            }
        }
        基础节点.节点数组_!(IR节点_) byArgns = .创建节点数组!(IR节点_)(baks, baksk);
        .编译确定的(ISK.右括号);
        摘要多值设置_ ba = 工厂.创建摘要多值设置(bak, byArgns);
        .追加!(IR节点_)(值组, .完成节点!(摘要多值设置_)(ba, bap));
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置值);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
模块摘要_ parseModuleEntry() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.module_);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 路径开始 = .获取节点开始();
    IR令牌_!(ISK) pk = .编译确定IR令牌!(ISK)(ISK.path);
    .编译确定的(ISK.冒号);
    IR文本字面量_ Path = .parseStringConstant();
    .编译确定的(ISK.逗号);
    摘要值设置_ pn = 工厂.创建摘要值设置(pk, Path);
    .完成节点!(摘要值设置_)(pn, 路径开始);
    long hp = .获取节点开始();
    IR令牌_!(ISK) hk = .编译确定IR令牌!(ISK)(ISK.hash);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    IR数字字面量_ Hash0 = .parseUInt32();
    .追加!(IR节点_)(值组, Hash0);
    .编译确定的(ISK.逗号);
    IR数字字面量_ Hash1 = .parseUInt32();
    .追加!(IR节点_)(值组, Hash1);
    .编译确定的(ISK.逗号);
    IR数字字面量_ Hash2 = .parseUInt32();
    .追加!(IR节点_)(值组, Hash2);
    .编译确定的(ISK.逗号);
    IR数字字面量_ Hash3 = .parseUInt32();
    .追加!(IR节点_)(值组, Hash3);
    .编译确定的(ISK.逗号);
    IR数字字面量_ Hash4 = .parseUInt32();
    .追加!(IR节点_)(值组, Hash4);
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ h = 工厂.创建摘要多值设置(hk, 设置值);
    .完成节点!(摘要多值设置_)(h, hp);
    .编译确定的(ISK.右括号);
    模块摘要_ n = 工厂.创建模块摘要(pn, h);
    return .完成节点!(模块摘要_)(n, 开始);
}
全局值摘要_ parseGVEntry() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.gv);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    IR节点_ Name;
    IR数字字面量_ GUID;
    switch (.当前()) {
        case ISK.name: {
            .编译确定的(ISK.冒号);
            Name = .parseStringConstant();
            break;
        }
        case ISK.guid: {
            .编译确定的(ISK.冒号);
            GUID = .parseUInt64();
            break;
        }
        default: {
            .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
            break;
        }
    }
    if (!.编译可选的(ISK.逗号)) {
        .编译确定的(ISK.右括号);
        全局值摘要_ n = 工厂.创建全局值摘要(Name, GUID);
        return .完成节点!(全局值摘要_)(n, 开始);
    }
    long 摘要组开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.summaries);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    bool 应循环 = true;
    IR节点_[] 设置组 = 创建数组!(IR节点_)();
    while(应循环) {
        switch (.当前()) {
            case ISK.function_: {
                函数摘要_ 值 = .parseFunctionSummary();
                .追加!(IR节点_)(设置组, 值);
                break;
            }
            case ISK.variable: {
                变量摘要_ 值 = .parseVariableSummary();
                .追加!(IR节点_)(设置组, 值);
                break;
            }
            case ISK.alias_: {
                别名摘要_ 值 = .parseAliasSummary();
                .追加!(IR节点_)(设置组, 值);
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 值组 = .创建节点数组!(IR节点_)(设置组, 数组开始);
    摘要多值设置_ 设置 = 工厂.创建摘要多值设置(键, 值组);
    .编译确定的(ISK.右括号);
    .编译确定的(ISK.右括号);
    全局值摘要_ n = 工厂.创建全局值摘要(Name, GUID, 设置);
    return .完成节点!(全局值摘要_)(n, 开始);
}
函数摘要_ parseFunctionSummary() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.function_);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    摘要值设置_ 模块引用 = .parseModuleReference();
    .编译确定的(ISK.逗号);
    摘要多值设置_ 全局标志 = .parseGVFlags();
    .编译确定的(ISK.逗号);
    long 学院组开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.insts);
    .编译确定的(ISK.冒号);
    IR数字字面量_ 值 = .parseUInt32();
    摘要值设置_ 学院设置 = 工厂.创建摘要值设置(键, 值);
    .完成节点!(摘要值设置_)(学院设置, 学院组开始);
    long 数组开始 = -1;
    IR节点_[] 值组;
    while(.编译可选的(ISK.逗号)) {
        if (数组开始 == -1) {
            数组开始 = .获取节点开始();
            值组 = 创建数组!(IR节点_)();
        }
        switch (.当前()) {
            case ISK.funcFlags: {
                .追加!(IR节点_)(值组, .parseOptionalFFlags());
                break;
            }
            case ISK.calls: {
                .追加!(IR节点_)(值组, .parseOptionalCalls());
                break;
            }
            case ISK.typeIdInfo: {
                .追加!(IR节点_)(值组, .parseOptionalTypeIdInfo());
                break;
            }
            case ISK.refs: {
                .追加!(IR节点_)(值组, .parseOptionalRefs());
                break;
            }
            case ISK.params: {
                .追加!(IR节点_)(值组, .parseOptionalParamAccesses());
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
    }
    基础节点.节点数组_!(IR节点_) 设置值;
    if ((值组 !is ··null!(IR节点_[])) && 值组.length > 0) {
        设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    }
    .编译确定的(ISK.右括号);
    函数摘要_ n = 工厂.创建函数摘要(模块引用, 全局标志, 学院设置, 设置值);
    return .完成节点!(函数摘要_)(n, 开始);
}
摘要多值设置_ parseOptionalParamAccesses() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.params);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        形参访问摘要_ ParamAccess = .parseParamAccess();
        .追加!(IR节点_)(值组, ParamAccess);
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置值);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
形参访问摘要_ parseParamAccess() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.左括号);
    摘要值设置_ ParamNo = .parseParamNo();
    .编译确定的(ISK.逗号);
    形参偏移摘要_ Offsets = .parseParamAccessOffset();
    IR节点_ calls;
    if (.编译可选的(ISK.逗号)) {
        long 成员开始 = .获取节点开始();
        IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.calls);
        .编译确定的(ISK.冒号);
        .编译确定的(ISK.左括号);
        long 数组开始 = .获取节点开始();
        IR节点_[] 值组 = 创建数组!(IR节点_)();
        bool 应循环 = true;
        while(应循环) {
            形参访问调用摘要_ VC = .parseParamAccessCall();
            .追加!(IR节点_)(值组, VC);
            应循环 = .编译可选的(ISK.逗号);
        }
        基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
        .编译确定的(ISK.右括号);
        摘要多值设置_ ns = 工厂.创建摘要多值设置(k, 设置值);
        calls = .完成节点!(摘要多值设置_)(ns, 成员开始);
    }
    .编译确定的(ISK.右括号);
    形参访问摘要_ n = 工厂.创建形参访问摘要(ParamNo, Offsets, calls);
    return .完成节点!(形参访问摘要_)(n, 开始);
}
形参访问调用摘要_ parseParamAccessCall() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.左括号);
    .编译确定的(ISK.callee);
    .编译确定的(ISK.冒号);
    全局值引用摘要_ VI = .parseGVReference();
    IR节点_ Offsets;
    IR节点_ ParamNo;
    if (.编译可选的(ISK.逗号)) {
        ParamNo = .parseParamNo();
        .编译确定的(ISK.逗号);
        Offsets = .parseParamAccessOffset();
    }
    .编译可选的(ISK.右括号);
    形参访问调用摘要_ n = 工厂.创建形参访问调用摘要(VI, ParamNo, Offsets);
    return .完成节点!(形参访问调用摘要_)(n, 开始);
}
形参偏移摘要_ parseParamAccessOffset() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.offset);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左方括号);
    IR数字字面量_ Lower = .getAPSIntVal();
    .编译确定的(ISK.逗号);
    IR数字字面量_ Upper = .getAPSIntVal();
    .编译确定的(ISK.右方括号);
    形参偏移摘要_ n = 工厂.创建形参偏移摘要(Lower, Upper);
    return .完成节点!(形参偏移摘要_)(n, 开始);
}
摘要值设置_ parseParamNo() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.param);
    .编译确定的(ISK.冒号);
    IR数字字面量_ ParamNo = .parseUInt64();
    摘要值设置_ n = 工厂.创建摘要值设置(键, ParamNo);
    return .完成节点!(摘要值设置_)(n, 开始);
}
摘要多值设置_ parseOptionalRefs() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.refs);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        全局值引用摘要_ VC = .parseGVReference();
        .追加!(IR节点_)(值组, VC);
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置值);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
摘要值设置_ parseModuleReference() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.module_);
    .编译确定的(ISK.冒号);
    IR数字字面量_ ModuleID = .getUIntVal();
    摘要值设置_ n = 工厂.创建摘要值设置(键, ModuleID);
    return .完成节点!(摘要值设置_)(n, 开始);
}
摘要多值设置_ parseGVFlags() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.flags);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        switch (.当前()) {
            case ISK.linkage: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.linkage);
                .编译确定的(ISK.冒号);
                IR节点_ v = .parseOptionalLinkageAux();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.visibility: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.visibility);
                .编译确定的(ISK.冒号);
                IR节点_ v = .parseOptionalVisibility();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.notEligibleToImport: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.notEligibleToImport);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.live: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.live);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.dsoLocal: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.dsoLocal);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.canAutoHide: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.canAutoHide);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置值);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
IR数字字面量_ parseFlag() {
    return .getAPSIntVal();
}
摘要多值设置_ parseOptionalFFlags() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.funcFlags);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        switch (.当前()) {
            case ISK.readNone: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.readNone);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.readOnly: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.readOnly);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.noRecurse: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.noRecurse);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.returnDoesNotAlias: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.returnDoesNotAlias);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.noInline: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.noInline);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.alwaysInline: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.alwaysInline);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.noUnwind: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.noUnwind);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.mayThrow: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.mayThrow);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.hasUnknownCall: {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.hasUnknownCall);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置值);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
摘要多值设置_ parseOptionalCalls() {
    long 开始 = .获取节点开始();
    IR令牌_!(ISK) 键 = .编译确定IR令牌!(ISK)(ISK.calls);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        long 设置开始 = .获取节点开始();
        .编译确定的(ISK.左括号);
        long 内容开始开始 = .获取节点开始();
        .编译确定IR令牌!(ISK)(ISK.callee);
        .编译确定的(ISK.冒号);
        全局值引用摘要_ 全局引用 = .parseGVReference();
        IR节点_ 热度或频率设置;
        if (.编译可选的(ISK.逗号)) {
            if (.当前() == ISK.hotness) {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.hotness);
                .编译确定的(ISK.冒号);
                IR节点_ v = .parseHotness();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                热度或频率设置 = .完成节点!(摘要值设置_)(值, p);
                break;
            }
            else {
                long p = .获取节点开始();
                IR令牌_!(ISK) k = .编译确定IR令牌!(ISK)(ISK.relbf);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseUInt32();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                热度或频率设置 = .完成节点!(摘要值设置_)(值, p);
                break;
            }
        }
        .编译确定的(ISK.右括号);
        被调用者摘要_ 被调用者 = 工厂.创建被调用者摘要(全局引用, 热度或频率设置);
        .追加!(IR节点_)(值组, .完成节点!(被调用者摘要_)(被调用者, 设置开始));
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置组 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置组);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
IR节点_ parseHotness() {
    switch (.当前()) {
        case ISK.unknown:
        case ISK.cold:
        case ISK.none:
        case ISK.hot:
        case ISK.critical: {
            return .编译IR令牌节点(.当前());
        }
        default: {
            return .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
        }
    }
}
全局值引用摘要_ parseGVReference() {
    long 开始 = .获取节点开始();
    IR节点_ ReadOnly;
    IR节点_ WriteOnly;
    if (.当前() == ISK.readonly) {
        ReadOnly = .编译IR令牌节点(.当前());
    }
    else if (.当前() == ISK.writeonly) {
        WriteOnly = .编译IR令牌节点(.当前());
    }
    IR数字字面量_ GVID = .getUIntVal();
    全局值引用摘要_ n = 工厂.创建全局值引用摘要(GVID, ReadOnly ? ReadOnly : WriteOnly);
    return .完成节点!(全局值引用摘要_)(n, 开始);
}
摘要多值设置_ parseOptionalTypeIdInfo() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(ISK.typeIdInfo);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        switch (.当前()) {
            case ISK.typeTests: {
                摘要多值设置_ 值 = .parseTypeTests();
                .追加!(IR节点_)(值组, 值);
                break;
            }
            case ISK.typeTestAssumeVCalls: {
                摘要多值设置_ 值 = .parseVFuncIdList();
                .追加!(IR节点_)(值组, 值);
                break;
            }
            case ISK.typeCheckedLoadVCalls: {
                摘要多值设置_ 值 = .parseVFuncIdList();
                .追加!(IR节点_)(值组, 值);
                break;
            }
            case ISK.typeTestAssumeConstVCalls: {
                摘要多值设置_ 值 = .parseConstVCallList();
                .追加!(IR节点_)(值组, 值);
                break;
            }
            case ISK.typeCheckedLoadConstVCalls: {
                摘要多值设置_ 值 = .parseConstVCallList();
                .追加!(IR节点_)(值组, 值);
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置组 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, new 基础节点.节点数组_!(IR节点_)(值组));
    return .完成节点!(摘要多值设置_)(n, 开始);
}
摘要多值设置_ parseConstVCallList() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(.当前());
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        常量虚调用摘要_ call = .parseConstVCall();
        .追加!(IR节点_)(值组, call);
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置组 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置组);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
常量虚调用摘要_ parseConstVCall() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.左括号);
    虚函数id摘要_ id = .parseVFuncId();
    IR节点_ args;
    if (.编译可选的(ISK.逗号)) {
        args = .parseArgs();
    }
    .编译确定的(ISK.右括号);
    常量虚调用摘要_ n = 工厂.创建常量虚调用摘要(id, args);
    return .完成节点!(常量虚调用摘要_)(n, 开始);
}
摘要多值设置_ parseArgs() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(ISK.args);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        IR数字字面量_ Val = .parseUInt64();
        .追加!(IR节点_)(值组, Val);
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置组 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置组);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
摘要多值设置_ parseVFuncIdList() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(.当前());
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        虚函数id摘要_ id = .parseVFuncId();
        .追加!(IR节点_)(值组, id);
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置组 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置组);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
虚函数id摘要_ parseVFuncId() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.vFuncId);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    IR标识符_ ID;
    IR节点_ GUID;
    if (.当前() == ISK.SummaryID) {
        IR数字字面量_ id = .getUIntVal();
        ID = 工厂.创建IR标识符(标识符分类_.特性标识符_ | 标识符分类_.ID标识符_, id);
    }
    else {
        .编译确定的(ISK.guid);
        .编译确定的(ISK.冒号);
        GUID = .parseUInt64();
    }
    .编译确定的(ISK.逗号);
    .编译确定的(ISK.offset);
    .编译确定的(ISK.冒号);
    IR数字字面量_ Offset = .parseUInt64();
    .编译确定的(ISK.右括号);
    虚函数id摘要_ n = 工厂.创建虚函数id摘要(Offset, ID, GUID);
    return .完成节点!(虚函数id摘要_)(n, 开始);
}
摘要多值设置_ parseTypeTests() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(ISK.typeTests);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        if (.当前() == ISK.SummaryID) {
            IR数字字面量_ id = .getUIntVal();
            IR标识符_ ID = 工厂.创建IR标识符(标识符分类_.特性标识符_ | 标识符分类_.ID标识符_, id);
            .追加!(IR节点_)(值组, ID);
        }
        else {
            IR数字字面量_ GUID = .parseUInt64();
            .追加!(IR节点_)(值组, GUID);
        }
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置组 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置组);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
变量摘要_ parseVariableSummary() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.variable);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    摘要值设置_ ModulePath = .parseModuleReference();
    .编译确定的(ISK.逗号);
    摘要多值设置_ GVFlags = .parseGVFlags();
    .编译确定的(ISK.逗号);
    摘要多值设置_ GVarFlags = .parseGVarFlags();
    long 数组开始 = -1;
    IR节点_[] 值组;
    while(.编译可选的(ISK.逗号)) {
        if (数组开始 == -1) {
            数组开始 = .获取节点开始();
            值组 = 创建数组!(IR节点_)();
        }
        switch (.当前()) {
            case ISK.vTableFuncs: {
                摘要多值设置_ VTableFuncs = .parseOptionalVTableFuncs();
                .追加!(IR节点_)(值组, VTableFuncs);
                break;
            }
            case ISK.refs: {
                摘要多值设置_ Refs = .parseOptionalRefs();
                .追加!(IR节点_)(值组, Refs);
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
    }
    基础节点.节点数组_!(IR节点_) 设置值;
    if ((值组 !is ··null!(IR节点_[])) && 值组.length > 0) {
        设置值 = .创建节点数组!(IR节点_)(值组, 数组开始);
    }
    .编译确定的(ISK.右括号);
    变量摘要_ n = 工厂.创建变量摘要(ModulePath, GVFlags, GVarFlags, 设置值);
    return .完成节点!(变量摘要_)(n, 开始);
}
摘要多值设置_ parseGVarFlags() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(ISK.varFlags);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        switch (.当前()) {
            case ISK.readonly: {
                long p = .获取节点开始();
                IR节点_ k = .编译IR令牌节点(ISK.readonly);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.writeonly: {
                long p = .获取节点开始();
                IR节点_ k = .编译IR令牌节点(ISK.writeonly);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.constant: {
                long p = .获取节点开始();
                IR节点_ k = .编译IR令牌节点(ISK.constant);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            case ISK.vcall_visibility: {
                long p = .获取节点开始();
                IR节点_ k = .编译IR令牌节点(ISK.vcall_visibility);
                .编译确定的(ISK.冒号);
                IR数字字面量_ v = .parseFlag();
                摘要值设置_ 值 = 工厂.创建摘要值设置(k, v);
                .追加!(IR节点_)(值组, .完成节点!(摘要值设置_)(值, p));
                break;
            }
            default: {
                .创建失踪IR节点!(IR节点_)(.当前(), true, 诊断集_.意外的令牌_0);
                break;
            }
        }
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置组 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置组);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
摘要多值设置_ parseOptionalVTableFuncs() {
    long 开始 = .获取节点开始();
    IR节点_ 键 = .编译IR令牌节点(ISK.vTableFuncs);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    long 数组开始 = .获取节点开始();
    IR节点_[] 值组 = 创建数组!(IR节点_)();
    bool 应循环 = true;
    while(应循环) {
        long 元素开始 = .获取节点开始();
        .编译确定的(ISK.左括号);
        .编译确定的(ISK.virtFunc);
        .编译确定的(ISK.冒号);
        全局值引用摘要_ VI = .parseGVReference();
        .编译确定的(ISK.逗号);
        .编译确定的(ISK.offset);
        .编译确定的(ISK.冒号);
        IR数字字面量_ Offset = .parseUInt64();
        .编译确定的(ISK.右括号);
        虚函数摘要_ ns = 工厂.创建虚函数摘要(VI, Offset);
        .追加!(IR节点_)(值组, .完成节点!(虚函数摘要_)(ns, 元素开始));
        应循环 = .编译可选的(ISK.逗号);
    }
    基础节点.节点数组_!(IR节点_) 设置组 = .创建节点数组!(IR节点_)(值组, 数组开始);
    .编译确定的(ISK.右括号);
    摘要多值设置_ n = 工厂.创建摘要多值设置(键, 设置组);
    return .完成节点!(摘要多值设置_)(n, 开始);
}
别名摘要_ parseAliasSummary() {
    long 开始 = .获取节点开始();
    .编译确定的(ISK.alias_);
    .编译确定的(ISK.冒号);
    .编译确定的(ISK.左括号);
    摘要值设置_ ModulePath = .parseModuleReference();
    .编译确定的(ISK.逗号);
    摘要多值设置_ GVFlags = .parseGVFlags();
    .编译确定的(ISK.逗号);
    .编译确定的(ISK.aliasee);
    .编译确定的(ISK.冒号);
    全局值引用摘要_ AliaseeVI = .parseGVReference();
    .编译确定的(ISK.右括号);
    别名摘要_ n = 工厂.创建别名摘要(ModulePath, GVFlags, AliaseeVI);
    return .完成节点!(别名摘要_)(n, 开始);
}
